@firebase/data-connect 0.3.11-20250716004940 → 0.3.11-caching-fdc.9f17eac6e

package/dist/index.cjs.js

@@ -8,7 +8,7 @@ var util = require('@firebase/util');
 var logger$1 = require('@firebase/logger');
 
 const name = "@firebase/data-connect";
-const version = "0.3.11-20250716004940";
+const version = "0.3.11-caching-fdc.9f17eac6e";
 
 /**
  * @license
@@ -36,69 +36,6 @@ function setSDKVersion(version) {
     SDK_VERSION = version;
 }
 
-/**
- * @license
- * Copyright 2024 Google LLC
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-/**
- * @internal
- * Abstraction around AppCheck's token fetching capabilities.
- */
-class AppCheckTokenProvider {
-    constructor(app$1, appCheckProvider) {
-        this.appCheckProvider = appCheckProvider;
-        if (app._isFirebaseServerApp(app$1) && app$1.settings.appCheckToken) {
-            this.serverAppAppCheckToken = app$1.settings.appCheckToken;
-        }
-        this.appCheck = appCheckProvider?.getImmediate({ optional: true });
-        if (!this.appCheck) {
-            void appCheckProvider
-                ?.get()
-                .then(appCheck => (this.appCheck = appCheck))
-                .catch();
-        }
-    }
-    getToken() {
-        if (this.serverAppAppCheckToken) {
-            return Promise.resolve({ token: this.serverAppAppCheckToken });
-        }
-        if (!this.appCheck) {
-            return new Promise((resolve, reject) => {
-                // Support delayed initialization of FirebaseAppCheck. This allows our
-                // customers to initialize the RTDB SDK before initializing Firebase
-                // AppCheck and ensures that all requests are authenticated if a token
-                // becomes available before the timoeout below expires.
-                setTimeout(() => {
-                    if (this.appCheck) {
-                        this.getToken().then(resolve, reject);
-                    }
-                    else {
-                        resolve(null);
-                    }
-                }, 0);
-            });
-        }
-        return this.appCheck.getToken();
-    }
-    addTokenChangeListener(listener) {
-        void this.appCheckProvider
-            ?.get()
-            .then(appCheck => appCheck.addTokenListener(listener));
-    }
-}
-
 /**
  * @license
  * Copyright 2024 Google LLC
@@ -178,6 +115,769 @@ function logError(msg) {
     logger.error(`DataConnect (${SDK_VERSION}): ${msg}`);
 }
 
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class ImpactedQueryRefsAccumulator {
+    constructor() {
+        this.impacted = new Set();
+    }
+    add(impacted) {
+        impacted.forEach(ref => this.impacted.add(ref));
+    }
+    consumeEvents() {
+        const events = Array.from(this.impacted);
+        this.impacted.clear();
+        return events;
+    }
+}
+
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class EntityDataObject {
+    getMap() {
+        return this.map;
+    }
+    getStorableMap(map) {
+        const newMap = {};
+        for (const key in map) {
+            if (map.hasOwnProperty(key)) {
+                newMap[key] = map[key];
+            }
+        }
+        return newMap;
+    }
+    toStorableJson() {
+        return {
+            globalID: this.globalID,
+            map: this.getStorableMap(this.map),
+            queriesReferenced: this.queriesReferenced
+        };
+    }
+    static fromStorableJson(json) {
+        const bdo = new EntityDataObject(json.globalID);
+        bdo.map = json.map;
+        bdo.queriesReferenced = json.queriesReferenced;
+        return bdo;
+    }
+    constructor(globalID) {
+        this.globalID = globalID;
+        this.map = {};
+        this.queriesReferenced = new Set();
+    }
+    updateServerValue(key, value, requestedFrom) {
+        this.map[key] = value;
+        this.queriesReferenced.add(requestedFrom);
+        return Array.from(this.queriesReferenced);
+    }
+}
+
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const GLOBAL_ID_KEY = '_id';
+class EntityNode {
+    constructor(acc = new ImpactedQueryRefsAccumulator()) {
+        this.acc = acc;
+        this.scalars = {};
+        this.references = {};
+        this.objectLists = {};
+        this.impactedQueryRefs = new Set();
+    }
+    async loadData(queryId, values, cacheProvider) {
+        if (values === undefined && cacheProvider === undefined) {
+            return;
+        }
+        if (typeof values !== 'object' || Array.isArray(values)) {
+            throw new DataConnectError('invalid-argument', 'EntityNode initialized with non-object value');
+        }
+        if (values === null) {
+            return;
+        }
+        if (values.hasOwnProperty(GLOBAL_ID_KEY) &&
+            typeof values[GLOBAL_ID_KEY] === 'string') {
+            this.globalId = values[GLOBAL_ID_KEY];
+            // TODO: Add current query id to BDO
+            this.entityData = await cacheProvider.getBdo(this.globalId);
+        }
+        for (const key in values) {
+            if (values.hasOwnProperty(key)) {
+                if (key === GLOBAL_ID_KEY) {
+                    continue;
+                }
+                if (typeof values[key] === 'object') {
+                    if (Array.isArray(values[key])) {
+                        const objArray = [];
+                        const scalarArray = [];
+                        for (const value of values[key]) {
+                            if (typeof value === 'object') {
+                                if (Array.isArray(value)) ;
+                                else {
+                                    const entityNode = new EntityNode(this.acc);
+                                    await entityNode.loadData(queryId, value, cacheProvider);
+                                    objArray.push(entityNode);
+                                }
+                            }
+                            else {
+                                scalarArray.push(value);
+                            }
+                        }
+                        if (scalarArray.length > 0 && objArray.length > 0) {
+                            throw new DataConnectError('invalid-argument', 'Sparse array detected.');
+                        }
+                        if (scalarArray.length > 0) {
+                            if (this.entityData) {
+                                const impactedRefs = this.entityData.updateServerValue(key, scalarArray, queryId);
+                                this.acc.add(impactedRefs);
+                            }
+                            else {
+                                this.scalars[key] = scalarArray;
+                            }
+                        }
+                        else if (objArray.length > 0) {
+                            this.objectLists[key] = objArray;
+                        }
+                        else {
+                            this.scalars[key] = [];
+                        }
+                    }
+                    else {
+                        if (values[key] === null) {
+                            this.scalars[key] = null;
+                            continue;
+                        }
+                        const stubDataObject = new EntityNode(this.acc);
+                        await stubDataObject.loadData(queryId, values[key], cacheProvider);
+                        this.references[key] = stubDataObject;
+                    }
+                }
+                else {
+                    if (this.entityData) {
+                        // TODO: Track only the fields we need for the BDO
+                        const impactedRefs = this.entityData.updateServerValue(key, values[key], queryId);
+                        this.acc.add(impactedRefs);
+                    }
+                    else {
+                        this.scalars[key] = values[key];
+                    }
+                }
+            }
+        }
+        if (this.entityData) {
+            await cacheProvider.updateBackingData(this.entityData);
+        }
+    }
+    toJson() {
+        const resultObject = {};
+        const entityDataMap = this.entityData?.getMap();
+        for (const key in entityDataMap) {
+            if (entityDataMap?.hasOwnProperty(key)) {
+                resultObject[key] = entityDataMap[key];
+            }
+        }
+        // Scalars should never have stubdataobjects
+        for (const key in this.scalars) {
+            if (this.scalars.hasOwnProperty(key)) {
+                resultObject[key] = this.scalars[key];
+            }
+        }
+        for (const key in this.references) {
+            if (this.references.hasOwnProperty(key)) {
+                resultObject[key] = this.references[key].toJson();
+            }
+        }
+        for (const key in this.objectLists) {
+            if (this.objectLists.hasOwnProperty(key)) {
+                resultObject[key] = this.objectLists[key].map(obj => {
+                    return obj.toJson();
+                });
+            }
+        }
+        return resultObject;
+    }
+    static parseMap(map, isSdo = false) {
+        const newMap = {};
+        for (const key in map) {
+            if (map.hasOwnProperty(key)) {
+                if (Array.isArray(map[key])) {
+                    newMap[key] = map[key].map(value => isSdo ? EntityNode.fromStorableJson(value) : value);
+                }
+                else {
+                    newMap[key] = isSdo
+                        ? EntityNode.fromStorableJson(map[key])
+                        : map[key];
+                }
+            }
+        }
+        return newMap;
+    }
+    static fromStorableJson(obj) {
+        const sdo = new EntityNode();
+        if (obj.backingData) {
+            sdo.entityData = EntityDataObject.fromStorableJson(obj.backingData);
+        }
+        sdo.acc = new ImpactedQueryRefsAccumulator();
+        sdo.globalId = obj.globalID;
+        sdo.impactedQueryRefs = new Set();
+        sdo.scalars = EntityNode.parseMap(obj.scalars);
+        sdo.references = EntityNode.parseMap(obj.references);
+        sdo.objectLists = EntityNode.parseMap(obj.objectLists, true);
+        return sdo;
+    }
+    getStorableMap(map) {
+        const newMap = {};
+        for (const key in map) {
+            if (map.hasOwnProperty(key)) {
+                if (Array.isArray(map[key])) {
+                    newMap[key] = map[key].map(value => value.toStorableJson());
+                }
+                else {
+                    newMap[key] = map[key].toStorableJson();
+                }
+            }
+        }
+        return newMap;
+    }
+    toStorableJson() {
+        const obj = {
+            globalID: this.globalId,
+            scalars: this.scalars,
+            references: this.getStorableMap(this.references),
+            objectLists: this.getStorableMap(this.objectLists)
+        };
+        if (this.entityData) {
+            obj.backingData = this.entityData.toStorableJson();
+        }
+        return obj;
+    }
+}
+
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class ResultTree {
+    static parse(value) {
+        const rt = new ResultTree(value.data, EntityNode.fromStorableJson(value.rootStub), value.ttlInMs, value.cachedAt, value.lastAccessed);
+        return rt;
+    }
+    constructor(data, rootStub, ttlInMs = 30000, cachedAt, _lastAccessed) {
+        this.data = data;
+        this.rootStub = rootStub;
+        this.ttlInMs = ttlInMs;
+        this.cachedAt = cachedAt;
+        this._lastAccessed = _lastAccessed;
+    }
+    isStale() {
+        return (Date.now() - new Date(this.cachedAt.getTime()).getTime() > this.ttlInMs);
+    }
+    updateTtl(ttlInMs) {
+        this.ttlInMs = ttlInMs;
+    }
+    updateAccessed() {
+        this._lastAccessed = new Date();
+    }
+    get lastAccessed() {
+        return this._lastAccessed;
+    }
+    getRootStub() {
+        return this.rootStub;
+    }
+}
+
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const BDO_OBJECT_STORE_NAME = 'data-connect-bdos';
+const SRT_OBJECT_STORE_NAME = 'data-connect-srts';
+class IndexedDBCacheProvider {
+    isIdbAvailable() {
+        return typeof window !== 'undefined' && 'indexedDB' in window;
+    }
+    // TODO: Figure out how to deal with caching across tabs.
+    // We could use the web locks api
+    constructor(cacheId) {
+        this.cacheId = cacheId;
+        this.bdos = new Map();
+        this.resultTrees = new Map();
+        this.initialized = false;
+        if (!this.isIdbAvailable()) {
+            return;
+        }
+        this.idbManager = new IndexedDbManager(this.cacheId);
+        this.idbManager.open(1);
+    }
+    async initialize() {
+        // load BDOs
+        if (this.initialized) {
+            return;
+        }
+        const db = await this.idbManager.dbPromise;
+        const resultTrees = await this.idbManager.readFromDb(db);
+        resultTrees.forEach((resultTree, key) => {
+            this.resultTrees.set(key, resultTree);
+        });
+    }
+    async commitBdoChanges(backingData) {
+        // TODO: Move these into a new function.
+        if (!this.isIdbAvailable()) {
+            return;
+        }
+        await this.initialize();
+        void this.idbManager.updateBdo(backingData);
+    }
+    async commitResultTreeChanges(queryId, rt) {
+        if (!this.isIdbAvailable()) {
+            return;
+        }
+        await this.initialize();
+        void this.idbManager.updateResultTree(rt, queryId);
+    }
+    async setResultTree(queryId, rt) {
+        this.resultTrees.set(queryId, rt);
+        // maybe this needs to be async?
+        // TODO: replace array with valid data
+        await this.commitResultTreeChanges(queryId, rt);
+    }
+    async getResultTree(queryId) {
+        await this.initialize();
+        const ret = this.resultTrees.get(queryId);
+        return ret;
+    }
+    createGlobalId() {
+        return crypto.randomUUID();
+    }
+    async getBdo(globalId) {
+        await this.initialize();
+        if (!this.bdos.has(globalId)) {
+            this.bdos.set(globalId, new EntityDataObject(globalId));
+        }
+        // Because of the above, we can guarantee that there will be a BDO at the globalId.
+        return this.bdos.get(globalId);
+    }
+    async updateBackingData(backingData) {
+        this.bdos.set(backingData.globalID, backingData);
+        await this.commitBdoChanges(backingData);
+    }
+    async close() {
+        await this.idbManager.close();
+    }
+}
+const dbName = 'data-connect';
+class IndexedDbManager {
+    constructor(cacheId) {
+        this.cacheId = cacheId;
+        this.alreadyRead = false;
+    }
+    open(version) {
+        this.dbPromise = new Promise((dbResolve, dbReject) => {
+            // TODO: See when, or if ever, cacheId is null
+            const request = indexedDB.open(`${dbName}-${this.cacheId}`, version);
+            request.onupgradeneeded = event => {
+                // TODO: Handle what happens if the version changes.
+                const db = event.target.result;
+                db.createObjectStore(BDO_OBJECT_STORE_NAME);
+                db.createObjectStore(SRT_OBJECT_STORE_NAME);
+                dbResolve(db);
+            };
+            request.onsuccess = async (event) => {
+                const db = event.target.result;
+                dbResolve(db);
+            };
+            request.onerror = error => {
+                // TODO(mtewani): Use proper error.
+                dbReject(error);
+            };
+        });
+    }
+    async updateBdo(backingData) {
+        const db = await this.dbPromise;
+        db.transaction([BDO_OBJECT_STORE_NAME], 'readwrite')
+            .objectStore(BDO_OBJECT_STORE_NAME)
+            .put(backingData, backingData.globalID);
+    }
+    async updateResultTree(rt, queryId) {
+        const db = await this.dbPromise;
+        const objectStore = db
+            .transaction([SRT_OBJECT_STORE_NAME], 'readwrite')
+            .objectStore(SRT_OBJECT_STORE_NAME);
+        // TODO: What happens if you override an existing entry?
+        // TODO: We should first check whether the tree is hydrated or not.
+        // TODO: We should make sure that everything has been written.
+        objectStore.put(rt.getRootStub().toStorableJson(), queryId);
+    }
+    async readFromDb(db) {
+        const resultTrees = new Map();
+        if (this.alreadyRead) {
+            return resultTrees;
+        }
+        const bdos = new Map();
+        const tx = db.transaction([BDO_OBJECT_STORE_NAME, SRT_OBJECT_STORE_NAME], 'readonly');
+        const bdoStore = tx.objectStore(BDO_OBJECT_STORE_NAME);
+        const srtStore = tx.objectStore(SRT_OBJECT_STORE_NAME);
+        const bdoComplete = new Promise((resolve, reject) => {
+            const openCursor = bdoStore.openCursor();
+            openCursor.onsuccess = event => {
+                const cursor = event.target
+                    .result;
+                if (cursor) {
+                    bdos.set(cursor.key, EntityDataObject.fromStorableJson(cursor.value));
+                    cursor.continue();
+                }
+                else {
+                    // No more entries
+                    resolve(null);
+                }
+            };
+            openCursor.onerror = error => {
+                console.error(error);
+                reject(error);
+            };
+        });
+        const srtComplete = new Promise((resolve, reject) => {
+            const openCursor = srtStore.openCursor();
+            openCursor.onsuccess = event => {
+                const cursor = event.target
+                    .result;
+                if (cursor) {
+                    const srt = ResultTree.parse(cursor.value);
+                    resultTrees.set(cursor.key, srt);
+                    cursor.continue();
+                }
+                else {
+                    // No more entries
+                    resolve(null);
+                }
+            };
+            openCursor.onerror = error => {
+                console.error(error);
+                reject(error);
+            };
+        });
+        await Promise.all([bdoComplete, srtComplete]);
+        return resultTrees;
+    }
+    async close() {
+        const db = await this.dbPromise;
+        db.close();
+    }
+}
+
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class InMemoryCacheProvider {
+    constructor(_keyId) {
+        this._keyId = _keyId;
+        this.bdos = new Map();
+        this.resultTrees = new Map();
+    }
+    setResultTree(queryId, rt) {
+        this.resultTrees.set(queryId, rt);
+        return Promise.resolve();
+    }
+    // TODO: Should this be in the cache provider? This seems common along all CacheProviders.
+    async getResultTree(queryId) {
+        return this.resultTrees.get(queryId);
+    }
+    createGlobalId() {
+        return crypto.randomUUID();
+    }
+    updateBackingData(backingData) {
+        this.bdos.set(backingData.globalID, backingData);
+        return Promise.resolve();
+    }
+    async getBdo(globalId) {
+        if (!this.bdos.has(globalId)) {
+            this.bdos.set(globalId, new EntityDataObject(globalId));
+        }
+        // Because of the above, we can guarantee that there will be a BDO at the globalId.
+        return this.bdos.get(globalId);
+    }
+    close() {
+        // TODO: Noop
+        return Promise.resolve();
+    }
+}
+
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class ResultTreeProcessor {
+    hydrateResults(rootStubObject) {
+        return JSON.stringify(rootStubObject.toJson());
+    }
+    async dehydrateResults(json, cacheProvider, acc, queryId) {
+        const stubDataObject = new EntityNode(acc);
+        await stubDataObject.loadData(queryId, json, cacheProvider);
+        return {
+            stubDataObject,
+            data: JSON.stringify(stubDataObject.toStorableJson())
+        };
+    }
+}
+
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class DataConnectCache {
+    constructor(authProvider, projectId, connectorConfig, host, cacheSettings) {
+        this.authProvider = authProvider;
+        this.projectId = projectId;
+        this.connectorConfig = connectorConfig;
+        this.host = host;
+        this.cacheSettings = cacheSettings;
+        this.cacheProvider = null;
+        this.uid = null;
+        this.authProvider.addTokenChangeListener(async (_) => {
+            const newUid = this.authProvider.getAuth().getUid();
+            // We should only close if the token changes and so does the new UID
+            if (this.uid !== newUid) {
+                await this.cacheProvider?.close();
+                this.uid = newUid;
+                const identifier = await this.getIdentifier(this.uid);
+                this.cacheProvider = this.initializeNewProviders(identifier);
+            }
+        });
+    }
+    async initialize() {
+        if (!this.cacheProvider) {
+            const identifier = await this.getIdentifier(this.uid);
+            this.cacheProvider = this.initializeNewProviders(identifier);
+        }
+    }
+    async getIdentifier(uid) {
+        const identifier = `${this.cacheSettings?.cacheProvider instanceof IndexedDBStub
+            ? 'persistent'
+            : 'memory'}-${this.projectId}-${this.connectorConfig.service}-${this.connectorConfig.connector}-${this.connectorConfig.location}-${uid}-${this.host}`;
+        const sha256 = await util.generateSHA256HashBrowser(identifier);
+        return sha256;
+    }
+    initializeNewProviders(identifier) {
+        let cacheProvider;
+        if (this.cacheSettings) {
+            cacheProvider =
+                this.cacheSettings.cacheProvider?.type === 'MEMORY' ||
+                    !util.isIndexedDBAvailable()
+                    ? new InMemoryCacheProvider(identifier)
+                    : new IndexedDBCacheProvider(identifier);
+        }
+        else {
+            logDebug('IndexedDB is not available. Using In-Memory Cache Provider instead.');
+            cacheProvider = new InMemoryCacheProvider(identifier);
+        }
+        return cacheProvider;
+    }
+    async containsResultTree(queryId) {
+        await this.initialize();
+        const resultTree = await this.cacheProvider.getResultTree(queryId);
+        return resultTree !== undefined;
+    }
+    async getResultTree(queryId) {
+        await this.initialize();
+        const cacheProvider = this.cacheProvider;
+        return cacheProvider.getResultTree(queryId);
+    }
+    async getResultJSON(queryId) {
+        await this.initialize();
+        const processor = new ResultTreeProcessor();
+        const cacheProvider = this.cacheProvider;
+        const resultTree = await cacheProvider.getResultTree(queryId);
+        if (!resultTree) {
+            throw new DataConnectError('invalid-argument', `${queryId} not found in cache. Call "update() first."`);
+        }
+        return processor.hydrateResults(resultTree.getRootStub());
+    }
+    async update(queryId, serverValues) {
+        const processor = new ResultTreeProcessor();
+        const acc = new ImpactedQueryRefsAccumulator();
+        const cacheProvider = this.cacheProvider;
+        const { data, stubDataObject } = await processor.dehydrateResults(serverValues, cacheProvider, acc, queryId);
+        const now = new Date();
+        // TODO: Check if ttl actually gets passed.
+        // TODO: Check API Proposal fields.
+        await cacheProvider.setResultTree(queryId, new ResultTree(data, stubDataObject, serverValues.ttl, now, now));
+        return acc.consumeEvents();
+    }
+}
+class IndexedDBStub {
+    constructor() {
+        this.type = 'PERSISTENT';
+    }
+}
+class MemoryStub {
+    constructor() {
+        this.type = 'MEMORY';
+    }
+}
+
+/**
+ * @license
+ * Copyright 2024 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * @internal
+ * Abstraction around AppCheck's token fetching capabilities.
+ */
+class AppCheckTokenProvider {
+    constructor(app$1, appCheckProvider) {
+        this.appCheckProvider = appCheckProvider;
+        if (app._isFirebaseServerApp(app$1) && app$1.settings.appCheckToken) {
+            this.serverAppAppCheckToken = app$1.settings.appCheckToken;
+        }
+        this.appCheck = appCheckProvider?.getImmediate({ optional: true });
+        if (!this.appCheck) {
+            void appCheckProvider
+                ?.get()
+                .then(appCheck => (this.appCheck = appCheck))
+                .catch();
+        }
+    }
+    getToken() {
+        if (this.serverAppAppCheckToken) {
+            return Promise.resolve({ token: this.serverAppAppCheckToken });
+        }
+        if (!this.appCheck) {
+            return new Promise((resolve, reject) => {
+                // Support delayed initialization of FirebaseAppCheck. This allows our
+                // customers to initialize the RTDB SDK before initializing Firebase
+                // AppCheck and ensures that all requests are authenticated if a token
+                // becomes available before the timoeout below expires.
+                setTimeout(() => {
+                    if (this.appCheck) {
+                        this.getToken().then(resolve, reject);
+                    }
+                    else {
+                        resolve(null);
+                    }
+                }, 0);
+            });
+        }
+        return this.appCheck.getToken();
+    }
+    addTokenChangeListener(listener) {
+        void this.appCheckProvider
+            ?.get()
+            .then(appCheck => appCheck.addTokenListener(listener));
+    }
+}
+
 /**
  * @license
  * Copyright 2024 Google LLC
@@ -205,6 +905,9 @@ class FirebaseAuthProvider {
             _authProvider.onInit(auth => (this._auth = auth));
         }
     }
+    getAuth() {
+        return this._auth;
+    }
     getToken(forceRefresh) {
         if (!this._auth) {
             return new Promise((resolve, reject) => {
@@ -279,14 +982,20 @@ const SOURCE_CACHE = 'CACHE';
  * limitations under the License.
  */
 let encoderImpl;
+let decoderImpl;
 function setEncoder(encoder) {
     encoderImpl = encoder;
 }
+function setDecoder(decoder) {
+    decoderImpl = decoder;
+}
+// TODO(mtewani): Fix issue where if fields are out of order, caching breaks.
 setEncoder(o => JSON.stringify(o));
+setDecoder(s => JSON.parse(s));
 
 /**
  * @license
- * Copyright 2024 Google LLC
+ * Copyright 2025 Google LLC
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -300,11 +1009,11 @@ setEncoder(o => JSON.stringify(o));
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-function setIfNotExists(map, key, val) {
-    if (!map.has(key)) {
-        map.set(key, val);
-    }
-}
+const QueryFetchPolicy = {
+    PREFER_CACHE: 'PREFER_CACHE',
+    CACHE_ONLY: 'CACHE_ONLY',
+    SERVER_ONLY: 'SERVER_ONLY'
+};
 
 /**
  * @license
@@ -334,32 +1043,35 @@ function getRefSerializer(queryRef, data, source) {
                     ...queryRef.dataConnect.getSettings()
                 }
             },
-            fetchTime: Date.now().toLocaleString(),
+            fetchTime: Date.now().toLocaleString(), // TODO: Fix the fetch time here.
             source
         };
     };
 }
 class QueryManager {
-    constructor(transport) {
+    constructor(transport, cache, dc) {
         this.transport = transport;
-        this._queries = new Map();
+        this.cache = cache;
+        this.dc = dc;
+        this.callbacks = new Map();
+        this.queue = [];
+    }
+    async waitForQueuedWrites() {
+        for (const promise of this.queue) {
+            await promise;
+        }
+        this.queue = [];
+    }
+    updateSSR(updatedData) {
+        this.queue.push(this.updateCache(updatedData).then(async (result) => this.publishCacheResultsToSubscribers(result)));
     }
-    track(queryName, variables, initialCache) {
-        const ref = {
-            name: queryName,
-            variables,
+    async updateCache(result) {
+        await this.waitForQueuedWrites();
+        return this.cache.update(encoderImpl({
+            name: result.ref.name,
+            variables: result.ref.variables,
             refType: QUERY_STR
-        };
-        const key = encoderImpl(ref);
-        const newTrackedQuery = {
-            ref,
-            subscriptions: [],
-            currentCache: initialCache || null,
-            lastError: null
-        };
-        // @ts-ignore
-        setIfNotExists(this._queries, key, newTrackedQuery);
-        return this._queries.get(key);
+        }), result.data);
     }
     addSubscription(queryRef, onResultCallback, onErrorCallback, initialCache) {
         const key = encoderImpl({
@@ -367,98 +1079,119 @@ class QueryManager {
             variables: queryRef.variables,
             refType: QUERY_STR
         });
-        const trackedQuery = this._queries.get(key);
-        const subscription = {
-            userCallback: onResultCallback,
-            errCallback: onErrorCallback
-        };
         const unsubscribe = () => {
-            const trackedQuery = this._queries.get(key);
-            trackedQuery.subscriptions = trackedQuery.subscriptions.filter(sub => sub !== subscription);
-        };
-        if (initialCache && trackedQuery.currentCache !== initialCache) {
-            logDebug('Initial cache found. Comparing dates.');
-            if (!trackedQuery.currentCache ||
-                (trackedQuery.currentCache &&
-                    compareDates(trackedQuery.currentCache.fetchTime, initialCache.fetchTime))) {
-                trackedQuery.currentCache = initialCache;
+            if (this.callbacks.has(key)) {
+                const callbackList = this.callbacks.get(key);
+                this.callbacks.set(key, callbackList.filter(callback => callback.userCallback !== onResultCallback));
             }
+        };
+        if (initialCache) {
+            this.updateSSR(initialCache);
         }
-        if (trackedQuery.currentCache !== null) {
-            const cachedData = trackedQuery.currentCache.data;
-            onResultCallback({
-                data: cachedData,
-                source: SOURCE_CACHE,
-                ref: queryRef,
-                toJSON: getRefSerializer(queryRef, trackedQuery.currentCache.data, SOURCE_CACHE),
-                fetchTime: trackedQuery.currentCache.fetchTime
-            });
-            if (trackedQuery.lastError !== null && onErrorCallback) {
-                onErrorCallback(undefined);
-            }
+        logDebug(`Cache not available for query ${queryRef.name} with variables ${JSON.stringify(queryRef.variables)}. Calling executeQuery.`);
+        const promise = this.executeQuery(queryRef);
+        // We want to ignore the error and let subscriptions handle it
+        promise.then(undefined, err => { });
+        if (!this.callbacks.has(key)) {
+            this.callbacks.set(key, []);
         }
-        trackedQuery.subscriptions.push({
+        this.callbacks.get(key).push({
             userCallback: onResultCallback,
             errCallback: onErrorCallback,
             unsubscribe
         });
-        if (!trackedQuery.currentCache) {
-            logDebug(`No cache available for query ${queryRef.name} with variables ${JSON.stringify(queryRef.variables)}. Calling executeQuery.`);
-            const promise = this.executeQuery(queryRef);
-            // We want to ignore the error and let subscriptions handle it
-            promise.then(undefined, err => { });
-        }
         return unsubscribe;
     }
-    executeQuery(queryRef) {
+    async executeQuery(queryRef, options) {
+        await this.waitForQueuedWrites();
         if (queryRef.refType !== QUERY_STR) {
-            throw new DataConnectError(Code.INVALID_ARGUMENT, `ExecuteQuery can only execute query operation`);
+            throw new DataConnectError(Code.INVALID_ARGUMENT, `ExecuteQuery can only execute query operations`);
         }
         const key = encoderImpl({
             name: queryRef.name,
             variables: queryRef.variables,
             refType: QUERY_STR
         });
-        const trackedQuery = this._queries.get(key);
-        const result = this.transport.invokeQuery(queryRef.name, queryRef.variables);
-        const newR = result.then(res => {
+        if (options?.fetchPolicy !== QueryFetchPolicy.SERVER_ONLY &&
+            (await this.cache.containsResultTree(key)) &&
+            !(await this.cache.getResultTree(key)).isStale()) {
+            const cacheResult = JSON.parse(await this.cache.getResultJSON(key));
+            const resultTree = await this.cache.getResultTree(key);
+            const result = {
+                source: SOURCE_CACHE,
+                ref: queryRef,
+                data: cacheResult,
+                toJSON: getRefSerializer(queryRef, cacheResult, SOURCE_CACHE),
+                fetchTime: resultTree.cachedAt.toString()
+            };
+            (await this.cache.getResultTree(key)).updateAccessed();
+            logDebug(`Cache found for query ${queryRef.name} with variables ${JSON.stringify(queryRef.variables)}. Calling executeQuery`);
+            return result;
+        }
+        else {
+            if (options?.fetchPolicy === QueryFetchPolicy.SERVER_ONLY) {
+                logDebug(`Skipping cache for fetch policy "serverOnly"`);
+            }
+            else {
+                logDebug(`No Cache found for query ${queryRef.name} with variables ${JSON.stringify(queryRef.variables)}. Calling executeQuery`);
+            }
+        }
+        try {
+            const res = await this.transport.invokeQuery(queryRef.name, queryRef.variables);
             const fetchTime = new Date().toString();
             const result = {
-                ...res,
+                data: res.data,
                 source: SOURCE_SERVER,
                 ref: queryRef,
                 toJSON: getRefSerializer(queryRef, res.data, SOURCE_SERVER),
                 fetchTime
             };
-            trackedQuery.subscriptions.forEach(subscription => {
-                subscription.userCallback(result);
-            });
-            trackedQuery.currentCache = {
-                data: res.data,
-                source: SOURCE_CACHE,
-                fetchTime
-            };
+            if (await this.cache.containsResultTree(key)) {
+                (await this.cache.getResultTree(key)).updateAccessed();
+            }
+            const impactedQueries = await this.cache.update(key, result.data);
+            await this.publishCacheResultsToSubscribers(impactedQueries);
             return result;
-        }, err => {
-            trackedQuery.lastError = err;
-            trackedQuery.subscriptions.forEach(subscription => {
+        }
+        catch (err) {
+            this.callbacks.get(key)?.forEach(subscription => {
                 if (subscription.errCallback) {
                     subscription.errCallback(err);
                 }
             });
             throw err;
-        });
-        return newR;
+        }
+    }
+    async publishCacheResultsToSubscribers(impactedQueries) {
+        for (const query of impactedQueries) {
+            const callbacks = this.callbacks.get(query);
+            if (!callbacks) {
+                continue;
+            }
+            const newJson = (await this.cache.getResultTree(query))
+                .getRootStub()
+                .toJson();
+            const { name, variables } = decoderImpl(query);
+            const queryRef = {
+                dataConnect: this.dc,
+                refType: QUERY_STR,
+                name,
+                variables
+            };
+            callbacks.forEach(callback => {
+                callback.userCallback({
+                    data: newJson,
+                    fetchTime: new Date().toISOString(),
+                    source: SOURCE_CACHE,
+                    ref: queryRef
+                });
+            });
+        }
     }
     enableEmulator(host, port) {
         this.transport.useEmulator(host, port);
     }
 }
-function compareDates(str1, str2) {
-    const date1 = new Date(str1);
-    const date2 = new Date(str2);
-    return date1.getTime() < date2.getTime();
-}
 
 /**
  * @license
@@ -501,11 +1234,12 @@ const CallerSdkTypeEnum = {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+const PROD_HOST = 'firebasedataconnect.googleapis.com';
 function urlBuilder(projectConfig, transportOptions) {
     const { connector, location, projectId: project, service } = projectConfig;
     const { host, sslEnabled, port } = transportOptions;
     const protocol = sslEnabled ? 'https' : 'http';
-    const realHost = host || `firebasedataconnect.googleapis.com`;
+    const realHost = host || PROD_HOST;
     let baseUrl = `${protocol}://${realHost}`;
     if (typeof port === 'number') {
         baseUrl += `:${port}`;
@@ -585,7 +1319,7 @@ function dcFetch(url, body, { signal }, appId, accessToken, appCheckToken, _isUs
         throw new DataConnectError(Code.OTHER, 'Failed to fetch: ' + JSON.stringify(err));
     })
         .then(async (response) => {
-        let jsonResponse = null;
+        let jsonResponse;
         try {
             jsonResponse = await response.json();
         }
@@ -615,7 +1349,7 @@ function dcFetch(url, body, { signal }, appId, accessToken, appCheckToken, _isUs
     });
 }
 function getMessage(obj) {
-    if ('message' in obj) {
+    if ('message' in obj && obj.message) {
         return obj.message;
     }
     return JSON.stringify(obj);
@@ -731,7 +1465,10 @@ class RESTTransport {
     async getWithAuth(forceToken = false) {
         let starterPromise = new Promise(resolve => resolve(this._accessToken));
         if (this.appCheckProvider) {
-            this._appCheckToken = (await this.appCheckProvider.getToken())?.token;
+            const appCheckToken = await this.appCheckProvider.getToken();
+            if (appCheckToken) {
+                this._appCheckToken = appCheckToken.token;
+            }
         }
         if (this.authProvider) {
             starterPromise = this.authProvider
@@ -934,20 +1671,27 @@ class DataConnect {
         if (this._authProvider) {
             this._authTokenProvider = new FirebaseAuthProvider(this.app.name, this.app.options, this._authProvider);
         }
+        const connectorConfig = {
+            connector: this.dataConnectOptions.connector,
+            service: this.dataConnectOptions.service,
+            location: this.dataConnectOptions.location
+        };
+        this.cache = new DataConnectCache(this._authTokenProvider, this.app.options.projectId, connectorConfig, this._transportOptions?.host || PROD_HOST, this.dataConnectOptions.cacheSettings);
         if (this._appCheckProvider) {
             this._appCheckTokenProvider = new AppCheckTokenProvider(this.app, this._appCheckProvider);
         }
-        this._initialized = true;
         this._transport = new this._transportClass(this.dataConnectOptions, this.app.options.apiKey, this.app.options.appId, this._authTokenProvider, this._appCheckTokenProvider, undefined, this._isUsingGeneratedSdk, this._callerSdkType);
         if (this._transportOptions) {
             this._transport.useEmulator(this._transportOptions.host, this._transportOptions.port, this._transportOptions.sslEnabled);
         }
-        this._queryManager = new QueryManager(this._transport);
+        this._queryManager = new QueryManager(this._transport, this.cache, this);
         this._mutationManager = new MutationManager(this._transport);
+        this._initialized = true;
     }
     // @internal
     enableEmulator(transportOptions) {
-        if (this._initialized &&
+        if (this._transportOptions &&
+            this._initialized &&
             !areTransportOptionsEqual(this._transportOptions, transportOptions)) {
             logError('enableEmulator called after initialization');
             throw new DataConnectError(Code.ALREADY_INITIALIZED, 'DataConnect instance already initialized!');
@@ -982,21 +1726,31 @@ function connectDataConnectEmulator(dc, host, port, sslEnabled = false) {
     }
     dc.enableEmulator({ host, port, sslEnabled });
 }
-function getDataConnect(appOrOptions, optionalOptions) {
+function getDataConnect(appOrConnectorConfig, settingsOrConnectorConfig, settings // TODO: This doesn't serialize well because it has a function.
+) {
     let app$1;
-    let dcOptions;
-    if ('location' in appOrOptions) {
-        dcOptions = appOrOptions;
+    let connectorConfig;
+    let realSettings;
+    if ('location' in appOrConnectorConfig) {
+        connectorConfig = appOrConnectorConfig;
         app$1 = app.getApp();
+        realSettings = settingsOrConnectorConfig;
     }
     else {
-        dcOptions = optionalOptions;
-        app$1 = appOrOptions;
+        app$1 = appOrConnectorConfig;
+        connectorConfig = settingsOrConnectorConfig;
+        realSettings = settings;
     }
     if (!app$1 || Object.keys(app$1).length === 0) {
         app$1 = app.getApp();
     }
+    const dcOptions = {
+        ...realSettings,
+        ...connectorConfig,
+        projectId: app$1.options.projectId
+    };
     const provider = app._getProvider(app$1, 'data-connect');
+    // TODO: Deal with the parsing of these options properly.
     const identifier = JSON.stringify(dcOptions);
     if (provider.isInitialized(identifier)) {
         const dcInstance = provider.getImmediate({ identifier });
@@ -1007,7 +1761,7 @@ function getDataConnect(appOrOptions, optionalOptions) {
             return dcInstance;
         }
     }
-    validateDCOptions(dcOptions);
+    validateDCOptions(connectorConfig);
     logDebug('Creating new DataConnect instance');
     // Initialize with options.
     return provider.initialize({
@@ -1042,6 +1796,12 @@ function terminate(dataConnect) {
     return dataConnect._delete();
     // TODO(mtewani): Stop pending tasks
 }
+const StorageType = {
+    MEMORY: 'MEMORY'
+};
+function makeMemoryCacheProvider() {
+    return new MemoryStub();
+}
 
 /**
  * @license
@@ -1100,8 +1860,8 @@ function registerDataConnect(variant) {
  * @param queryRef query to execute.
  * @returns `QueryPromise`
  */
-function executeQuery(queryRef) {
-    return queryRef.dataConnect._queryManager.executeQuery(queryRef);
+function executeQuery(queryRef, options) {
+    return queryRef.dataConnect._queryManager.executeQuery(queryRef, options);
 }
 /**
  * Execute Query
@@ -1113,12 +1873,14 @@ function executeQuery(queryRef) {
  */
 function queryRef(dcInstance, queryName, variables, initialCache) {
     dcInstance.setInitialized();
-    dcInstance._queryManager.track(queryName, variables, initialCache);
+    if (initialCache !== undefined) {
+        dcInstance._queryManager.updateSSR(initialCache);
+    }
     return {
         dataConnect: dcInstance,
         refType: QUERY_STR,
         name: queryName,
-        variables
+        variables: variables
     };
 }
 /**
@@ -1176,7 +1938,7 @@ function validateArgs(connectorConfig, dcOrVars, vars, validateVars) {
 
 /**
  * @license
- * Copyright 2024 Google LLC
+ * Copyright 2025 Google LLC
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -1241,16 +2003,21 @@ exports.Code = Code;
 exports.DataConnect = DataConnect;
 exports.DataConnectError = DataConnectError;
 exports.DataConnectOperationError = DataConnectOperationError;
+exports.IndexedDBStub = IndexedDBStub;
 exports.MUTATION_STR = MUTATION_STR;
 exports.MutationManager = MutationManager;
+exports.PersistentStub = MemoryStub;
 exports.QUERY_STR = QUERY_STR;
+exports.QueryFetchPolicy = QueryFetchPolicy;
 exports.SOURCE_CACHE = SOURCE_CACHE;
 exports.SOURCE_SERVER = SOURCE_SERVER;
+exports.StorageType = StorageType;
 exports.areTransportOptionsEqual = areTransportOptionsEqual;
 exports.connectDataConnectEmulator = connectDataConnectEmulator;
 exports.executeMutation = executeMutation;
 exports.executeQuery = executeQuery;
 exports.getDataConnect = getDataConnect;
+exports.makeMemoryCacheProvider = makeMemoryCacheProvider;
 exports.mutationRef = mutationRef;
 exports.parseOptions = parseOptions;
 exports.queryRef = queryRef;