Renamed files

Author: maneesht

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

@@ -31,8 +31,6 @@ 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 {
@@ -88,7 +86,7 @@ export function parseOptions(fullHost: string): TransportOptions {
 /**
  * DataConnectOptions including project id
  */
-export interface DataConnectOptions extends ConnectorConfig {
+export interface DataConnectOptions extends ConnectorConfig, DataConnectInitOptions {
   projectId: string;
 }
 
@@ -124,7 +122,7 @@ export class DataConnect {
         this._transportOptions = parseOptions(host);
       }
     }
-    this.cache = new DataConnectCache();
+    this.cache = new DataConnectCache(this.dataConnectOptions.cacheSettings);
   }
   // @internal
   _useGeneratedSdk(): void {
@@ -257,48 +255,71 @@ export function connectDataConnectEmulator(
   dc.enableEmulator({ host, port, sslEnabled });
 }
 
-export interface DataConnectConfigureOptions {
-  cacheProvider: CacheProvider
+// TODO: Can we do something to make sure that this is more tree-shakable?
+export enum Storage {
+  memory,
+  persistent
+}
+
+export interface CacheSettings {
+  storage: Storage;
+  maxSizeBytes: number;
+}
+
+export interface DataConnectInitOptions {
+  cacheSettings?: CacheSettings;
 }
 
 /**
  * Initialize DataConnect instance
  * @param options ConnectorConfig
  */
+export function getDataConnect(options: ConnectorConfig, extraOptions?: DataConnectInitOptions): DataConnect;
 export function getDataConnect(options: ConnectorConfig): DataConnect;
-/**
+/** 
  * Initialize DataConnect instance
  * @param app FirebaseApp to initialize to.
- * @param options ConnectorConfig
+ * @param connectorConfig ConnectorConfig
+ */
+export function getDataConnect(
+  app: FirebaseApp,
+  connectorConfig: ConnectorConfig,
+): DataConnect;
+
+/** 
+ * Initialize DataConnect instance
+ * @param app FirebaseApp to initialize to.
+ * @param connectorConfig ConnectorConfig
  */
 export function getDataConnect(
   app: FirebaseApp,
-  options: ConnectorConfig,
-  additionalOptions?: DataConnectConfigureOptions
+  connectorConfig: ConnectorConfig,
+  extraOptions: DataConnectInitOptions
 ): DataConnect;
+
 export function getDataConnect(
-  appOrOptions: FirebaseApp | ConnectorConfig,
-  optionalOptionsOrCacheOptions?: ConnectorConfig | DataConnectConfigureOptions,
-  additionalOptionsOrCacheOptions?: DataConnectConfigureOptions
+  appOrConnectorConfig: FirebaseApp | ConnectorConfig,
+  optionsOrConnectorConfig?: ConnectorConfig | DataConnectInitOptions,
+  extraOptions?: DataConnectInitOptions
 ): DataConnect {
   let app: FirebaseApp;
-  let dcOptions: ConnectorConfig;
-  let cacheOptions: DataConnectConfigureOptions;
-  if ('location' in appOrOptions) {
-    dcOptions = appOrOptions;
+  let connectorConfig: ConnectorConfig;
+  let options: DataConnectInitOptions;
+  if ('location' in appOrConnectorConfig) {
+    connectorConfig = appOrConnectorConfig;
     app = getApp();
-    cacheOptions = optionalOptionsOrCacheOptions as DataConnectConfigureOptions;
+    options = optionsOrConnectorConfig as DataConnectInitOptions;
   } else {
-    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();
+    app = appOrConnectorConfig;
+    connectorConfig = optionsOrConnectorConfig as ConnectorConfig;
+    options = extraOptions as DataConnectInitOptions;
   }
 
+  const dcOptions = {
+    ...options,
+    connectorConfig
+  };
+
   if (!app || Object.keys(app).length === 0) {
     app = getApp();
   }
@@ -313,7 +334,7 @@ export function getDataConnect(
       return dcInstance;
     }
   }
-  validateDCOptions(dcOptions);
+  validateDCOptions(connectorConfig);
 
   logDebug('Creating new DataConnect instance');
   // Initialize with options.

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

@@ -1,16 +1,17 @@
 import { isIndexedDBAvailable } from '@firebase/util';
 
+import { CacheSettings, Storage } from '../api';
 import { DataConnectError } from '../core/error';
 import { type AuthTokenProvider } from '../core/FirebaseAuthProvider';
+import { logDebug } from '../logger';
 
-import { BackingDataObject } from './BackingDataObject';
 import { CacheProvider } from './CacheProvider';
+import { EntityDataObject } from './EntityDataObject';
 import { ImpactedQueryRefsAccumulator } from './ImpactedQueryRefsAccumulator';
 import { IndexedDBCacheProvider } from './IndexedDBCacheProvider';
 import { ResultTree } from './ResultTree';
 import { ResultTreeProcessor } from './ResultTreeProcessor';
 
-
 export interface ServerValues {
   ttl: number;
 }
@@ -29,13 +30,17 @@ export class Cache {
     this.initializeNewProviders();
   }
   initializeNewProviders(): void {
-    if (!isIndexedDBAvailable()) {
+    if(this.cacheSettings) {
+      this.cacheProvider = this.cacheSettings.storage === Storage.persistent ? new IndexedDBCacheProvider() : new EphemeralCacheProvider();
+    } else if (!isIndexedDBAvailable()) {
+      logDebug('IndexedDB is not available. Using In-Memory Cache Provider instead.');
       this.cacheProvider = new EphemeralCacheProvider();
     } else {
+      logDebug('Initializing IndexedDB Cache Provider.');
       this.cacheProvider = new IndexedDBCacheProvider();
     }
   }
-  constructor() {
+  constructor(private cacheSettings?: CacheSettings) {
     this.initializeNewProviders();
   }
   containsResultTree(queryId: string): boolean {
@@ -74,7 +79,7 @@ export class Cache {
 }
 
 class EphemeralCacheProvider implements CacheProvider {
-  private bdos = new Map<string, BackingDataObject>();
+  private bdos = new Map<string, EntityDataObject>();
   private resultTrees = new Map<string, ResultTree>();
 
   setResultTree(queryId: string, rt: ResultTree): void {
@@ -87,12 +92,12 @@ class EphemeralCacheProvider implements CacheProvider {
   createGlobalId(): string {
     return crypto.randomUUID();
   }
-  updateBackingData(backingData: BackingDataObject): void {
+  updateBackingData(backingData: EntityDataObject): void {
     this.bdos.set(backingData.globalID, backingData);
   }
-  getBdo(globalId: string): BackingDataObject {
+  getBdo(globalId: string): EntityDataObject {
     if (!this.bdos.has(globalId)) {
-      this.bdos.set(globalId, new BackingDataObject(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)!;

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

@@ -1,9 +1,9 @@
-import { BackingDataObject } from "./BackingDataObject";
+import { EntityDataObject } from "./EntityDataObject";
 import { ResultTree } from "./ResultTree";
 
 export interface CacheProvider {
-    getBdo(globalId: string): BackingDataObject;
-    updateBackingData(backingData: BackingDataObject): void;
+    getBdo(globalId: string): EntityDataObject;
+    updateBackingData(backingData: EntityDataObject): void;
     createGlobalId(): string;
     getResultTree(queryId: string): ResultTree | undefined;
     setResultTree(queryId: string, resultTree: ResultTree): void;

…a-connect/src/cache/BackingDataObject.ts …ta-connect/src/cache/EntityDataObject.tspackages/data-connect/src/cache/BackingDataObject.ts renamed to packages/data-connect/src/cache/EntityDataObject.ts packages/data-connect/src/cache/BackingDataObject.ts renamed to packages/data-connect/src/cache/EntityDataObject.ts

@@ -6,16 +6,16 @@ export interface BackingDataObjectJson {
   globalID: string;
 }
 
-export class BackingDataObject {
+export class EntityDataObject {
   toStorableJson(): BackingDataObjectJson {
     return {
       globalID: this.globalID,
       map: this.map,
       queriesReferenced: this.queriesReferenced
     };
   }
-  static fromStorableJson(json: BackingDataObjectJson): BackingDataObject {
-    const bdo = new BackingDataObject(json.globalID);
+  static fromStorableJson(json: BackingDataObjectJson): EntityDataObject {
+    const bdo = new EntityDataObject(json.globalID);
     bdo.map = new Map<string, FDCScalarValue>(json.map);
     bdo.queriesReferenced = json.queriesReferenced;
     return bdo;

…data-connect/src/cache/StubDataObject.ts …ges/data-connect/src/cache/EntityNode.tspackages/data-connect/src/cache/StubDataObject.ts renamed to packages/data-connect/src/cache/EntityNode.ts packages/data-connect/src/cache/StubDataObject.ts renamed to packages/data-connect/src/cache/EntityNode.ts

@@ -1,16 +1,16 @@
 import { DataConnectError } from '../api';
 
-import { BackingDataObject, BackingDataObjectJson, FDCScalarValue } from './BackingDataObject';
 import { CacheProvider } from './CacheProvider';
+import { EntityDataObject, BackingDataObjectJson, FDCScalarValue } from './EntityDataObject';
 import { ImpactedQueryRefsAccumulator } from './ImpactedQueryRefsAccumulator';
 
 export const GLOBAL_ID_KEY = 'cacheId';
-export class StubDataObject {
-  backingData?: BackingDataObject;
+export class EntityNode {
+  entityData?: EntityDataObject;
   scalars: { [key: string]: FDCScalarValue } = {};
-  references: { [key: string]: StubDataObject } = {};
+  references: { [key: string]: EntityNode } = {};
   objectLists: {
-    [key: string]: StubDataObject[];
+    [key: string]: EntityNode[];
   } = {};
   globalId?: string;
   impactedQueryRefs = new Set<string>();
@@ -24,7 +24,7 @@ export class StubDataObject {
     if (typeof values !== 'object' || Array.isArray(values)) {
       throw new DataConnectError(
         'invalid-argument',
-        'StubDataObject initialized with non-object value'
+        'EntityNode initialized with non-object value'
       );
     }
     if (values === null) {
@@ -36,7 +36,7 @@ export class StubDataObject {
       typeof values[GLOBAL_ID_KEY] === 'string'
     ) {
       this.globalId = values[GLOBAL_ID_KEY];
-      this.backingData = cacheProvider.getBdo(this.globalId);
+      this.entityData = cacheProvider.getBdo(this.globalId);
     }
     for (const key in values) {
       if (values.hasOwnProperty(key)) {
@@ -45,14 +45,14 @@ export class StubDataObject {
         }
         if (typeof values[key] === 'object') {
           if (Array.isArray(values[key])) {
-            const objArray: StubDataObject[] = [];
+            const objArray: EntityNode[] = [];
             const scalarArray: Array<NonNullable<FDCScalarValue>> = [];
             for (const value of values[key]) {
               if (typeof value === 'object') {
                 if (Array.isArray(value)) {
                   // TODO: What if it's an array of arrays?
                 } else {
-                  objArray.push(new StubDataObject(value, cacheProvider, this.acc));
+                  objArray.push(new EntityNode(value, cacheProvider, this.acc));
                 }
               } else {
                 scalarArray.push(value);
@@ -65,8 +65,8 @@ export class StubDataObject {
               );
             }
             if (scalarArray.length > 0) {
-              if (this.backingData) {
-                const impactedRefs = this.backingData.updateServerValue(key, scalarArray);
+              if (this.entityData) {
+                const impactedRefs = this.entityData.updateServerValue(key, scalarArray);
                 this.acc.add(impactedRefs);
               } else {
                 this.scalars[key] = scalarArray;
@@ -81,17 +81,17 @@ export class StubDataObject {
               this.scalars[key] = null;
               continue;
             }
-            const stubDataObject = new StubDataObject(
+            const stubDataObject = new EntityNode(
               values[key],
               cacheProvider,
               this.acc
             );
             this.references[key] = stubDataObject;
           }
         } else {
-          if (this.backingData) {
+          if (this.entityData) {
             // TODO: Track only the fields we need for the BDO
-            const impactedRefs = this.backingData.updateServerValue(
+            const impactedRefs = this.entityData.updateServerValue(
               key,
               values[key]
             );
@@ -102,15 +102,15 @@ export class StubDataObject {
         }
       }
     }
-    if (this.backingData) {
-      cacheProvider.updateBackingData(this.backingData);
+    if (this.entityData) {
+      cacheProvider.updateBackingData(this.entityData);
     }
   }
   toJson(): object {
     const resultObject: object = {};
-    for (const key in this.backingData) {
-      if (this.backingData.hasOwnProperty(key)) {
-        resultObject[key] = this.backingData[key];
+    for (const key in this.entityData) {
+      if (this.entityData.hasOwnProperty(key)) {
+        resultObject[key] = this.entityData[key];
       }
     }
     // Scalars should never have stubdataobjects
@@ -133,23 +133,23 @@ export class StubDataObject {
     }
     return resultObject;
   }
-  static parseMap(map: {[key: string]: StubDataObject | StubDataObject[] | FDCScalarValue}, isSdo = false): typeof map {
+  static parseMap(map: {[key: string]: EntityNode | EntityNode[] | FDCScalarValue}, isSdo = false): typeof map {
     const newMap: typeof map = {};
     for (const key in map) {
       if(map.hasOwnProperty(key)) {
         if(Array.isArray(map[key])) {
-          newMap[key] = map[key].map(value => isSdo ? StubDataObject.fromStorableJson(value) : value);
+          newMap[key] = map[key].map(value => isSdo ? EntityNode.fromStorableJson(value) : value);
         } else {
-          newMap[key] = isSdo ? StubDataObject.fromStorableJson(map[key] as StubDataObjectJson) : map[key];
+          newMap[key] = isSdo ? EntityNode.fromStorableJson(map[key] as StubDataObjectJson) : map[key];
         }
       }
     }
     return newMap;
   }
-  static fromStorableJson(obj: StubDataObjectJson): StubDataObject {
-    const sdo = new StubDataObject();
+  static fromStorableJson(obj: StubDataObjectJson): EntityNode {
+    const sdo = new EntityNode();
     if(obj.backingData) {
-      sdo.backingData = BackingDataObject.fromStorableJson(obj.backingData);
+      sdo.entityData = EntityDataObject.fromStorableJson(obj.backingData);
     }
     sdo.acc = new ImpactedQueryRefsAccumulator();
     sdo.globalId = obj.globalID;
@@ -159,7 +159,7 @@ export class StubDataObject {
     sdo.objectLists = this.parseMap(obj.objectLists, true) as typeof sdo.objectLists;
     return sdo;
   }
-  getStorableMap(map: {[key: string]: StubDataObject | StubDataObject[]}): {[key: string]: StubDataObjectJson | StubDataObjectJson[]} {
+  getStorableMap(map: {[key: string]: EntityNode | EntityNode[]}): {[key: string]: StubDataObjectJson | StubDataObjectJson[]} {
     const newMap: {[key: string]: StubDataObjectJson | StubDataObjectJson[]} = {};
     for (const key in map) {
       if(map.hasOwnProperty(key)) {
@@ -179,8 +179,8 @@ export class StubDataObject {
       references: this.getStorableMap(this.references) as StubDataObjectJson['references'],
       objectLists: this.getStorableMap(this.objectLists) as StubDataObjectJson['objectLists']
     };
-    if(this.backingData) {
-      obj.backingData = this.backingData.toStorableJson();
+    if(this.entityData) {
+      obj.backingData = this.entityData.toStorableJson();
     }
     return obj;
   }