WIP

Author: maneesht

packages/data-connect/src/api/DataConnect.ts

@@ -31,6 +31,8 @@ import {
 } from '@firebase/util';
 
 import { Cache as DataConnectCache } from '../cache/Cache';
+import { CacheProvider } from '../cache/CacheProvider';
+import { IndexedDBCacheProvider } from '../cache/IndexedDBCacheProvider';
 import { AppCheckTokenProvider } from '../core/AppCheckTokenProvider';
 import { Code, DataConnectError } from '../core/error';
 import {
@@ -168,6 +170,7 @@ export class DataConnect {
         this.app.options,
         this._authProvider
       );
+      this.cache.setAuthProvider(this._authTokenProvider);
     }
     if (this._appCheckProvider) {
       this._appCheckTokenProvider = new AppCheckTokenProvider(
@@ -254,6 +257,10 @@ export function connectDataConnectEmulator(
   dc.enableEmulator({ host, port, sslEnabled });
 }
 
+export interface DataConnectConfigureOptions {
+  cacheProvider: CacheProvider
+}
+
 /**
  * Initialize DataConnect instance
  * @param options ConnectorConfig
@@ -266,21 +273,31 @@ export function getDataConnect(options: ConnectorConfig): DataConnect;
  */
 export function getDataConnect(
   app: FirebaseApp,
-  options: ConnectorConfig
+  options: ConnectorConfig,
+  additionalOptions?: DataConnectConfigureOptions
 ): DataConnect;
 export function getDataConnect(
   appOrOptions: FirebaseApp | ConnectorConfig,
-  optionalOptions?: ConnectorConfig
+  optionalOptionsOrCacheOptions?: ConnectorConfig | DataConnectConfigureOptions,
+  additionalOptionsOrCacheOptions?: DataConnectConfigureOptions
 ): DataConnect {
   let app: FirebaseApp;
   let dcOptions: ConnectorConfig;
+  let cacheOptions: DataConnectConfigureOptions;
   if ('location' in appOrOptions) {
     dcOptions = appOrOptions;
     app = getApp();
+    cacheOptions = optionalOptionsOrCacheOptions as DataConnectConfigureOptions;
   } else {
-    dcOptions = optionalOptions!;
+    dcOptions = optionalOptionsOrCacheOptions as ConnectorConfig;
+    cacheOptions = additionalOptionsOrCacheOptions as DataConnectConfigureOptions;
     app = appOrOptions;
   }
+  // TODO: initialize data connect with this.
+  if(!cacheOptions) {
+    // TODO: Make this a class that gets passed in.
+    cacheOptions.cacheProvider = new IndexedDBCacheProvider();
+  }
 
   if (!app || Object.keys(app).length === 0) {
     app = getApp();

packages/data-connect/src/api/query.ts

@@ -71,15 +71,27 @@ export interface QueryPromise<Data, Variables>
   // reserved for special actions like cancellation
 }
 
+
+export enum QueryFetchPolicy {
+  preferCache,
+  cacheOnly,
+  serverOnly
+}
+
+export interface ExecuteQueryOptions {
+  fetchPolicy: QueryFetchPolicy;
+}
+
 /**
  * Execute Query
  * @param queryRef query to execute.
  * @returns `QueryPromise`
  */
 export function executeQuery<Data, Variables>(
-  queryRef: QueryRef<Data, Variables>
+  queryRef: QueryRef<Data, Variables>,
+  options?: ExecuteQueryOptions
 ): QueryPromise<Data, Variables> {
-  return queryRef.dataConnect._queryManager.executeQuery(queryRef);
+  return queryRef.dataConnect._queryManager.executeQuery(queryRef, options);
 }
 
 /**
@@ -102,10 +114,10 @@ export function queryRef<Data>(
 export function queryRef<Data, Variables>(
   dcInstance: DataConnect,
   queryName: string,
-  variables: Variables
+  variables: Variables,
 ): QueryRef<Data, Variables>;
 /**
- * Execute QueryG
+ * Execute Query
  * @param dcInstance Data Connect instance to use.
  * @param queryName Query to execute
  * @param variables Variables to execute with

packages/data-connect/src/cache/BackingDataObject.ts

@@ -8,7 +8,6 @@ export interface BackingDataObjectJson {
 
 export class BackingDataObject {
   toStorableJson(): BackingDataObjectJson {
-    // TODO: This might not be ok.
     return {
       globalID: this.globalID,
       map: this.map,

packages/data-connect/src/cache/Cache.ts

@@ -1,6 +1,7 @@
 import { isIndexedDBAvailable } from '@firebase/util';
 
 import { DataConnectError } from '../core/error';
+import { type AuthTokenProvider } from '../core/FirebaseAuthProvider';
 
 import { BackingDataObject } from './BackingDataObject';
 import { CacheProvider } from './CacheProvider';
@@ -9,23 +10,33 @@ import { IndexedDBCacheProvider } from './IndexedDBCacheProvider';
 import { ResultTree } from './ResultTree';
 import { ResultTreeProcessor } from './ResultTreeProcessor';
 
+
 export interface ServerValues {
   ttl: number;
 }
 
-
-
+// TODO: Figure out how to deal with caching across browsers.
 export class Cache {
+  setAuthProvider(_authTokenProvider: AuthTokenProvider): void {
+    this.authProvider.addTokenChangeListener((newToken) => {
+      this.updateToken(newToken);
+    });
+  }
   private cacheProvider: CacheProvider;
-  constructor() {
-    // TODO: Include identifier for cacheprovider
+  private authProvider: AuthTokenProvider;
+  updateToken(_newToken: string): void {
+    // TODO: notify cacheproviders
+    this.initializeNewProviders();
+  }
+  initializeNewProviders(): void {
     if (!isIndexedDBAvailable()) {
       this.cacheProvider = new EphemeralCacheProvider();
     } else {
       this.cacheProvider = new IndexedDBCacheProvider();
     }
-    // TODO: Create one for Tanstack
-    // TODO: Deal with auth changes.
+  }
+  constructor() {
+    this.initializeNewProviders();
   }
   containsResultTree(queryId: string): boolean {
     const resultTree = this.cacheProvider.getResultTree(queryId);
@@ -43,7 +54,6 @@ export class Cache {
         `${queryId} not found in cache. Call "update() first."`
       );
     }
-    // TODO: Make sure that this serializes the references, not the objects themselves.
     return processor.hydrateResults(resultTree.getRootStub());
   }
   update(queryId: string, serverValues: ServerValues): string[] {

packages/data-connect/src/cache/IndexedDBCacheProvider.ts

@@ -25,7 +25,6 @@ export class IndexedDBCacheProvider implements CacheProvider {
         dbResolve(db);
       };
       request.onsuccess = async (event) => {
-        // TODO: Check version
         const db = (event.target as IDBOpenDBRequest).result;
         const tx = db.transaction(
           [BDO_OBJECT_STORE_NAME, SRT_OBJECT_STORE_NAME],

packages/data-connect/src/cache/StubDataObject.ts

@@ -21,7 +21,6 @@ export class StubDataObject {
     if(typeof values === 'undefined' && typeof cacheProvider === 'undefined' && typeof acc === 'undefined') {
       return;
     }
-    // TODO: validate that all other fields have been passed in.
     if (typeof values !== 'object' || Array.isArray(values)) {
       throw new DataConnectError(
         'invalid-argument',

packages/data-connect/src/core/QueryManager.ts

@@ -15,7 +15,7 @@
  * limitations under the License.
  */
 
-import { DataConnect } from '../api';
+import { DataConnect, ExecuteQueryOptions, QueryFetchPolicy } from '../api';
 import {
   DataConnectSubscription,
   OnErrorSubscription,
@@ -162,22 +162,22 @@ export class QueryManager {
     return unsubscribe;
   }
   executeQuery<Data, Variables>(
-    queryRef: QueryRef<Data, Variables>
+    queryRef: QueryRef<Data, Variables>,
+    options?: ExecuteQueryOptions
   ): QueryPromise<Data, Variables> {
     if (queryRef.refType !== QUERY_STR) {
       throw new DataConnectError(
         Code.INVALID_ARGUMENT,
-        `ExecuteQuery can only execute query operation`
+        `ExecuteQuery can only execute query operations`
       );
     }
     const key = encoderImpl({
       name: queryRef.name,
       variables: queryRef.variables,
       refType: QUERY_STR
     });
-    // TODO: Check if the cache is stale
-    // TODO: isStale doesn't exist when parsing the raw JSON. Fix the parsing.
-    if(this.cache.containsResultTree(key) && !this.cache.getResultTree(key)?.isStale()) {
+
+    if (options.fetchPolicy !== QueryFetchPolicy.serverOnly && this.cache.containsResultTree(key) && !this.cache.getResultTree(key).isStale()) {
       const cacheResult: Data = JSON.parse(this.cache.getResultJSON(key));
       const result: QueryResult<Data, Variables> = {
           ...cacheResult,
@@ -191,11 +191,15 @@ export class QueryManager {
 
       return Promise.resolve(result);
     } else {
-      logDebug(
-        `No Cache found for query ${
-          queryRef.name
-        } with variables ${JSON.stringify(queryRef.variables)}. Calling executeQuery`
-      );
+      if(options.fetchPolicy === QueryFetchPolicy.serverOnly) {
+        logDebug(`Skipping cache for fetch policy "serverOnly"`);
+      } else {
+        logDebug(
+          `No Cache found for query ${
+            queryRef.name
+          } with variables ${JSON.stringify(queryRef.variables)}. Calling executeQuery`
+        );
+      }
     }
     const result = this.transport.invokeQuery<Data, Variables>(
       queryRef.name,
@@ -219,8 +223,7 @@ export class QueryManager {
         }
         if(this.cache.containsResultTree(key)) {
           this.cache.getResultTree(key).updateAccessed();
-        }
-        const impactedQueries = this.cache.update(key, result.data as ServerValues);
+        }        const impactedQueries = this.cache.update(key, result.data as ServerValues);
         this.publishCacheResultsToSubscribers(impactedQueries);
         return result;
       },