@firebase/app 0.7.18-20222320822 → 0.7.19

package/CHANGELOG.md

@@ -1,6 +1,18 @@
 # @firebase/app
 
-## 0.7.18-20222320822
+## 0.7.19
+
+### Patch Changes
+
+- [`2d672cead`](https://github.com/firebase/firebase-js-sdk/commit/2d672cead167187cb714cd89b638c0884ba58f03) [#6061](https://github.com/firebase/firebase-js-sdk/pull/6061) - Remove idb dependency and replace with our own code.
+
+* [`927c1afc1`](https://github.com/firebase/firebase-js-sdk/commit/927c1afc103e4f9b8a75320d3946a4c840445a2a) [#6039](https://github.com/firebase/firebase-js-sdk/pull/6039) - Fix heartbeat controller to ensure not sending more than one a day.
+
+* Updated dependencies [[`2d672cead`](https://github.com/firebase/firebase-js-sdk/commit/2d672cead167187cb714cd89b638c0884ba58f03)]:
+  - @firebase/util@1.5.0
+  - @firebase/component@0.5.11
+
+## 0.7.18
 
 ### Patch Changes
 

package/dist/app/src/heartbeatService.d.ts

@@ -16,7 +16,7 @@
  */
 import { ComponentContainer } from '@firebase/component';
 import { FirebaseApp } from './public-types';
-import { HeartbeatsByUserAgent, HeartbeatService, HeartbeatStorage, SingleDateHeartbeat } from './types';
+import { HeartbeatsByUserAgent, HeartbeatService, HeartbeatsInIndexedDB, HeartbeatStorage, SingleDateHeartbeat } from './types';
 export declare class HeartbeatServiceImpl implements HeartbeatService {
     private readonly container;
     /**
@@ -33,14 +33,14 @@ export declare class HeartbeatServiceImpl implements HeartbeatService {
      * be kept in sync with indexedDB.
      * Leave public for easier testing.
      */
-    _heartbeatsCache: SingleDateHeartbeat[] | null;
+    _heartbeatsCache: HeartbeatsInIndexedDB | null;
     /**
      * the initialization promise for populating heartbeatCache.
      * If getHeartbeatsHeader() is called before the promise resolves
      * (hearbeatsCache == null), it should wait for this promise
      * Leave public for easier testing.
      */
-    _heartbeatsCachePromise: Promise<SingleDateHeartbeat[]>;
+    _heartbeatsCachePromise: Promise<HeartbeatsInIndexedDB>;
     constructor(container: ComponentContainer);
     /**
      * Called to report a heartbeat. The function will generate
@@ -54,7 +54,8 @@ export declare class HeartbeatServiceImpl implements HeartbeatService {
      * Returns a base64 encoded string which can be attached to the heartbeat-specific header directly.
      * It also clears all heartbeats from memory as well as in IndexedDB.
      *
-     * NOTE: It will read heartbeats from the heartbeatsCache, instead of from indexedDB to reduce latency
+     * NOTE: Consuming product SDKs should not send the header if this method
+     * returns an empty string.
      */
     getHeartbeatsHeader(): Promise<string>;
 }
@@ -70,11 +71,9 @@ export declare class HeartbeatStorageImpl implements HeartbeatStorage {
     /**
      * Read all heartbeats.
      */
-    read(): Promise<SingleDateHeartbeat[]>;
-    overwrite(heartbeats: SingleDateHeartbeat[]): Promise<void>;
-    add(heartbeats: SingleDateHeartbeat[]): Promise<void>;
-    delete(heartbeats: SingleDateHeartbeat[]): Promise<void>;
-    deleteAll(): Promise<void>;
+    read(): Promise<HeartbeatsInIndexedDB>;
+    overwrite(heartbeatsObject: HeartbeatsInIndexedDB): Promise<void>;
+    add(heartbeatsObject: HeartbeatsInIndexedDB): Promise<void>;
 }
 /**
  * Calculate bytes of a HeartbeatsByUserAgent array after being wrapped

package/dist/app/src/indexeddb.d.ts

@@ -18,4 +18,3 @@ import { FirebaseApp } from './public-types';
 import { HeartbeatsInIndexedDB } from './types';
 export declare function readHeartbeatsFromIndexedDB(app: FirebaseApp): Promise<HeartbeatsInIndexedDB | undefined>;
 export declare function writeHeartbeatsToIndexedDB(app: FirebaseApp, heartbeatObject: HeartbeatsInIndexedDB): Promise<void>;
-export declare function deleteHeartbeatsFromIndexedDB(app: FirebaseApp): Promise<void>;

package/dist/app/src/types.d.ts

@@ -37,20 +37,19 @@ export interface HeartbeatService {
     getHeartbeatsHeader(): Promise<string>;
 }
 export interface HeartbeatsByUserAgent {
-    userAgent: string;
+    agent: string;
     dates: string[];
 }
 export interface SingleDateHeartbeat {
-    userAgent: string;
+    agent: string;
     date: string;
 }
 export interface HeartbeatStorage {
-    overwrite(heartbeats: SingleDateHeartbeat[]): Promise<void>;
-    add(heartbeats: SingleDateHeartbeat[]): Promise<void>;
-    delete(heartbeats: SingleDateHeartbeat[]): Promise<void>;
-    deleteAll(): Promise<void>;
-    read(): Promise<SingleDateHeartbeat[]>;
+    overwrite(heartbeats: HeartbeatsInIndexedDB): Promise<void>;
+    add(heartbeats: HeartbeatsInIndexedDB): Promise<void>;
+    read(): Promise<HeartbeatsInIndexedDB>;
 }
 export interface HeartbeatsInIndexedDB {
+    lastSentHeartbeatDate?: string;
     heartbeats: SingleDateHeartbeat[];
 }

package/dist/esm/app/src/heartbeatService.d.ts

@@ -16,7 +16,7 @@
  */
 import { ComponentContainer } from '@firebase/component';
 import { FirebaseApp } from './public-types';
-import { HeartbeatsByUserAgent, HeartbeatService, HeartbeatStorage, SingleDateHeartbeat } from './types';
+import { HeartbeatsByUserAgent, HeartbeatService, HeartbeatsInIndexedDB, HeartbeatStorage, SingleDateHeartbeat } from './types';
 export declare class HeartbeatServiceImpl implements HeartbeatService {
     private readonly container;
     /**
@@ -33,14 +33,14 @@ export declare class HeartbeatServiceImpl implements HeartbeatService {
      * be kept in sync with indexedDB.
      * Leave public for easier testing.
      */
-    _heartbeatsCache: SingleDateHeartbeat[] | null;
+    _heartbeatsCache: HeartbeatsInIndexedDB | null;
     /**
      * the initialization promise for populating heartbeatCache.
      * If getHeartbeatsHeader() is called before the promise resolves
      * (hearbeatsCache == null), it should wait for this promise
      * Leave public for easier testing.
      */
-    _heartbeatsCachePromise: Promise<SingleDateHeartbeat[]>;
+    _heartbeatsCachePromise: Promise<HeartbeatsInIndexedDB>;
     constructor(container: ComponentContainer);
     /**
      * Called to report a heartbeat. The function will generate
@@ -54,7 +54,8 @@ export declare class HeartbeatServiceImpl implements HeartbeatService {
      * Returns a base64 encoded string which can be attached to the heartbeat-specific header directly.
      * It also clears all heartbeats from memory as well as in IndexedDB.
      *
-     * NOTE: It will read heartbeats from the heartbeatsCache, instead of from indexedDB to reduce latency
+     * NOTE: Consuming product SDKs should not send the header if this method
+     * returns an empty string.
      */
     getHeartbeatsHeader(): Promise<string>;
 }
@@ -70,11 +71,9 @@ export declare class HeartbeatStorageImpl implements HeartbeatStorage {
     /**
      * Read all heartbeats.
      */
-    read(): Promise<SingleDateHeartbeat[]>;
-    overwrite(heartbeats: SingleDateHeartbeat[]): Promise<void>;
-    add(heartbeats: SingleDateHeartbeat[]): Promise<void>;
-    delete(heartbeats: SingleDateHeartbeat[]): Promise<void>;
-    deleteAll(): Promise<void>;
+    read(): Promise<HeartbeatsInIndexedDB>;
+    overwrite(heartbeatsObject: HeartbeatsInIndexedDB): Promise<void>;
+    add(heartbeatsObject: HeartbeatsInIndexedDB): Promise<void>;
 }
 /**
  * Calculate bytes of a HeartbeatsByUserAgent array after being wrapped

package/dist/esm/app/src/indexeddb.d.ts

@@ -18,4 +18,3 @@ import { FirebaseApp } from './public-types';
 import { HeartbeatsInIndexedDB } from './types';
 export declare function readHeartbeatsFromIndexedDB(app: FirebaseApp): Promise<HeartbeatsInIndexedDB | undefined>;
 export declare function writeHeartbeatsToIndexedDB(app: FirebaseApp, heartbeatObject: HeartbeatsInIndexedDB): Promise<void>;
-export declare function deleteHeartbeatsFromIndexedDB(app: FirebaseApp): Promise<void>;

package/dist/esm/app/src/types.d.ts

@@ -37,20 +37,19 @@ export interface HeartbeatService {
     getHeartbeatsHeader(): Promise<string>;
 }
 export interface HeartbeatsByUserAgent {
-    userAgent: string;
+    agent: string;
     dates: string[];
 }
 export interface SingleDateHeartbeat {
-    userAgent: string;
+    agent: string;
     date: string;
 }
 export interface HeartbeatStorage {
-    overwrite(heartbeats: SingleDateHeartbeat[]): Promise<void>;
-    add(heartbeats: SingleDateHeartbeat[]): Promise<void>;
-    delete(heartbeats: SingleDateHeartbeat[]): Promise<void>;
-    deleteAll(): Promise<void>;
-    read(): Promise<SingleDateHeartbeat[]>;
+    overwrite(heartbeats: HeartbeatsInIndexedDB): Promise<void>;
+    add(heartbeats: HeartbeatsInIndexedDB): Promise<void>;
+    read(): Promise<HeartbeatsInIndexedDB>;
 }
 export interface HeartbeatsInIndexedDB {
+    lastSentHeartbeatDate?: string;
     heartbeats: SingleDateHeartbeat[];
 }

package/dist/esm/index.esm2017.js

@@ -1,8 +1,7 @@
 import { Component, ComponentContainer } from '@firebase/component';
 import { Logger, setUserLogHandler, setLogLevel as setLogLevel$1 } from '@firebase/logger';
-import { ErrorFactory, deepEqual, base64Encode, isIndexedDBAvailable, validateIndexedDBOpenable } from '@firebase/util';
+import { ErrorFactory, deepEqual, openDB, base64urlEncodeWithoutPadding, isIndexedDBAvailable, validateIndexedDBOpenable } from '@firebase/util';
 export { FirebaseError } from '@firebase/util';
-import { openDb } from 'idb';
 
 /**
  * @license
@@ -58,7 +57,7 @@ function isVersionServiceProvider(provider) {
 }
 
 const name$o = "@firebase/app";
-const version$1 = "0.7.18-20222320822";
+const version$1 = "0.7.19";
 
 /**
  * @license
@@ -125,7 +124,7 @@ const name$2 = "@firebase/firestore";
 const name$1 = "@firebase/firestore-compat";
 
 const name = "firebase";
-const version = "9.6.8-20222320822";
+const version = "9.6.9";
 
 /**
  * @license
@@ -589,15 +588,15 @@ const STORE_NAME = 'firebase-heartbeat-store';
 let dbPromise = null;
 function getDbPromise() {
     if (!dbPromise) {
-        dbPromise = openDb(DB_NAME, DB_VERSION, upgradeDB => {
+        dbPromise = openDB(DB_NAME, DB_VERSION, (db, oldVersion) => {
             // We don't use 'break' in this switch statement, the fall-through
             // behavior is what we want, because if there are multiple versions between
             // the old version and the current version, we want ALL the migrations
             // that correspond to those versions to run, not only the last one.
             // eslint-disable-next-line default-case
-            switch (upgradeDB.oldVersion) {
+            switch (oldVersion) {
                 case 0:
-                    upgradeDB.createObjectStore(STORE_NAME);
+                    db.createObjectStore(STORE_NAME);
             }
         }).catch(e => {
             throw ERROR_FACTORY.create("storage-open" /* STORAGE_OPEN */, {
@@ -635,19 +634,6 @@ async function writeHeartbeatsToIndexedDB(app, heartbeatObject) {
         });
     }
 }
-async function deleteHeartbeatsFromIndexedDB(app) {
-    try {
-        const db = await getDbPromise();
-        const tx = db.transaction(STORE_NAME, 'readwrite');
-        await tx.objectStore(STORE_NAME).delete(computeKey(app));
-        return tx.complete;
-    }
-    catch (e) {
-        throw ERROR_FACTORY.create("storage-delete" /* STORAGE_DELETE */, {
-            originalErrorMessage: e.message
-        });
-    }
-}
 function computeKey(app) {
     return `${app.name}!${app.options.appId}`;
 }
@@ -704,21 +690,23 @@ class HeartbeatServiceImpl {
             .getImmediate();
         // This is the "Firebase user agent" string from the platform logger
         // service, not the browser user agent.
-        const userAgent = platformLogger.getPlatformInfoString();
+        const agent = platformLogger.getPlatformInfoString();
         const date = getUTCDateString();
         if (this._heartbeatsCache === null) {
             this._heartbeatsCache = await this._heartbeatsCachePromise;
         }
-        if (this._heartbeatsCache.some(singleDateHeartbeat => singleDateHeartbeat.date === date)) {
-            // Do not store a heartbeat if one is already stored for this day.
+        // Do not store a heartbeat if one is already stored for this day
+        // or if a header has already been sent today.
+        if (this._heartbeatsCache.lastSentHeartbeatDate === date ||
+            this._heartbeatsCache.heartbeats.some(singleDateHeartbeat => singleDateHeartbeat.date === date)) {
             return;
         }
         else {
             // There is no entry for this date. Create one.
-            this._heartbeatsCache.push({ date, userAgent });
+            this._heartbeatsCache.heartbeats.push({ date, agent });
         }
         // Remove entries older than 30 days.
-        this._heartbeatsCache = this._heartbeatsCache.filter(singleDateHeartbeat => {
+        this._heartbeatsCache.heartbeats = this._heartbeatsCache.heartbeats.filter(singleDateHeartbeat => {
             const hbTimestamp = new Date(singleDateHeartbeat.date).valueOf();
             const now = Date.now();
             return now - hbTimestamp <= STORED_HEARTBEAT_RETENTION_MAX_MILLIS;
@@ -729,31 +717,36 @@ class HeartbeatServiceImpl {
      * Returns a base64 encoded string which can be attached to the heartbeat-specific header directly.
      * It also clears all heartbeats from memory as well as in IndexedDB.
      *
-     * NOTE: It will read heartbeats from the heartbeatsCache, instead of from indexedDB to reduce latency
+     * NOTE: Consuming product SDKs should not send the header if this method
+     * returns an empty string.
      */
     async getHeartbeatsHeader() {
         if (this._heartbeatsCache === null) {
             await this._heartbeatsCachePromise;
         }
-        // If it's still null, it's been cleared and has not been repopulated.
-        if (this._heartbeatsCache === null) {
+        // If it's still null or the array is empty, there is no data to send.
+        if (this._heartbeatsCache === null ||
+            this._heartbeatsCache.heartbeats.length === 0) {
             return '';
         }
+        const date = getUTCDateString();
         // Extract as many heartbeats from the cache as will fit under the size limit.
-        const { heartbeatsToSend, unsentEntries } = extractHeartbeatsForHeader(this._heartbeatsCache);
-        const headerString = base64Encode(JSON.stringify({ version: 2, heartbeats: heartbeatsToSend }));
+        const { heartbeatsToSend, unsentEntries } = extractHeartbeatsForHeader(this._heartbeatsCache.heartbeats);
+        const headerString = base64urlEncodeWithoutPadding(JSON.stringify({ version: 2, heartbeats: heartbeatsToSend }));
+        // Store last sent date to prevent another being logged/sent for the same day.
+        this._heartbeatsCache.lastSentHeartbeatDate = date;
         if (unsentEntries.length > 0) {
             // Store any unsent entries if they exist.
-            this._heartbeatsCache = unsentEntries;
-            // This seems more likely than deleteAll (below) to lead to some odd state
+            this._heartbeatsCache.heartbeats = unsentEntries;
+            // This seems more likely than emptying the array (below) to lead to some odd state
             // since the cache isn't empty and this will be called again on the next request,
             // and is probably safest if we await it.
             await this._storage.overwrite(this._heartbeatsCache);
         }
         else {
-            this._heartbeatsCache = null;
+            this._heartbeatsCache.heartbeats = [];
             // Do not wait for this, to reduce latency.
-            void this._storage.deleteAll();
+            void this._storage.overwrite(this._heartbeatsCache);
         }
         return headerString;
     }
@@ -771,11 +764,11 @@ function extractHeartbeatsForHeader(heartbeatsCache, maxSize = MAX_HEADER_BYTES)
     let unsentEntries = heartbeatsCache.slice();
     for (const singleDateHeartbeat of heartbeatsCache) {
         // Look for an existing entry with the same user agent.
-        const heartbeatEntry = heartbeatsToSend.find(hb => hb.userAgent === singleDateHeartbeat.userAgent);
+        const heartbeatEntry = heartbeatsToSend.find(hb => hb.agent === singleDateHeartbeat.agent);
         if (!heartbeatEntry) {
             // If no entry for this user agent exists, create one.
             heartbeatsToSend.push({
-                userAgent: singleDateHeartbeat.userAgent,
+                agent: singleDateHeartbeat.agent,
                 dates: [singleDateHeartbeat.date]
             });
             if (countBytes(heartbeatsToSend) > maxSize) {
@@ -824,59 +817,46 @@ class HeartbeatStorageImpl {
     async read() {
         const canUseIndexedDB = await this._canUseIndexedDBPromise;
         if (!canUseIndexedDB) {
-            return [];
+            return { heartbeats: [] };
         }
         else {
             const idbHeartbeatObject = await readHeartbeatsFromIndexedDB(this.app);
-            return (idbHeartbeatObject === null || idbHeartbeatObject === void 0 ? void 0 : idbHeartbeatObject.heartbeats) || [];
+            return idbHeartbeatObject || { heartbeats: [] };
         }
     }
     // overwrite the storage with the provided heartbeats
-    async overwrite(heartbeats) {
-        const canUseIndexedDB = await this._canUseIndexedDBPromise;
-        if (!canUseIndexedDB) {
-            return;
-        }
-        else {
-            return writeHeartbeatsToIndexedDB(this.app, { heartbeats });
-        }
-    }
-    // add heartbeats
-    async add(heartbeats) {
+    async overwrite(heartbeatsObject) {
+        var _a;
         const canUseIndexedDB = await this._canUseIndexedDBPromise;
         if (!canUseIndexedDB) {
             return;
         }
         else {
-            const existingHeartbeats = await this.read();
+            const existingHeartbeatsObject = await this.read();
             return writeHeartbeatsToIndexedDB(this.app, {
-                heartbeats: [...existingHeartbeats, ...heartbeats]
+                lastSentHeartbeatDate: (_a = heartbeatsObject.lastSentHeartbeatDate) !== null && _a !== void 0 ? _a : existingHeartbeatsObject.lastSentHeartbeatDate,
+                heartbeats: heartbeatsObject.heartbeats
             });
         }
     }
-    // delete heartbeats
-    async delete(heartbeats) {
+    // add heartbeats
+    async add(heartbeatsObject) {
+        var _a;
         const canUseIndexedDB = await this._canUseIndexedDBPromise;
         if (!canUseIndexedDB) {
             return;
         }
         else {
-            const existingHeartbeats = await this.read();
+            const existingHeartbeatsObject = await this.read();
             return writeHeartbeatsToIndexedDB(this.app, {
-                heartbeats: existingHeartbeats.filter(existingHeartbeat => !heartbeats.includes(existingHeartbeat))
+                lastSentHeartbeatDate: (_a = heartbeatsObject.lastSentHeartbeatDate) !== null && _a !== void 0 ? _a : existingHeartbeatsObject.lastSentHeartbeatDate,
+                heartbeats: [
+                    ...existingHeartbeatsObject.heartbeats,
+                    ...heartbeatsObject.heartbeats
+                ]
             });
         }
     }
-    // delete all heartbeats
-    async deleteAll() {
-        const canUseIndexedDB = await this._canUseIndexedDBPromise;
-        if (!canUseIndexedDB) {
-            return;
-        }
-        else {
-            return deleteHeartbeatsFromIndexedDB(this.app);
-        }
-    }
 }
 /**
  * Calculate bytes of a HeartbeatsByUserAgent array after being wrapped
@@ -885,7 +865,7 @@ class HeartbeatStorageImpl {
  */
 function countBytes(heartbeatsCache) {
     // base64 has a restricted set of characters, all of which should be 1 byte.
-    return base64Encode(
+    return base64urlEncodeWithoutPadding(
     // heartbeatsCache wrapper properties
     JSON.stringify({ version: 2, heartbeats: heartbeatsCache })).length;
 }