tor-browser

ASRouterStorage.sys.mjs (10541B)

---

/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this file,
* You can obtain one at http://mozilla.org/MPL/2.0/. */

const lazy = {};

ChromeUtils.defineESModuleGetters(lazy, {
 IndexedDB: "resource://gre/modules/IndexedDB.sys.mjs",
 ProfilesDatastoreService:
   "moz-src:///toolkit/profile/ProfilesDatastoreService.sys.mjs",
 ASRouterPreferences:
   "resource:///modules/asrouter/ASRouterPreferences.sys.mjs",
});

export class ASRouterStorage {
 /**
  * @param storeNames Array of strings used to create all the required stores
  */
 constructor({ storeNames, telemetry }) {
   if (!storeNames) {
     throw new Error("storeNames required");
   }

   this.dbName = "ActivityStream";
   this.dbVersion = 3;
   this.storeNames = storeNames;
   this.telemetry = telemetry;
 }

 get db() {
   return this._db || (this._db = this.createOrOpenDb());
 }

 /**
  * Public method that binds the store required by the consumer and exposes
  * the private db getters and setters.
  *
  * @param storeName String name of desired store
  */
 getDbTable(storeName) {
   if (this.storeNames.includes(storeName)) {
     return {
       get: this._get.bind(this, storeName),
       getAll: this._getAll.bind(this, storeName),
       getAllKeys: this._getAllKeys.bind(this, storeName),
       set: this._set.bind(this, storeName),
       getSharedMessageImpressions:
         this.getSharedMessageImpressions.bind(this),
       getSharedMessageBlocklist: this.getSharedMessageBlocklist.bind(this),
       setSharedMessageImpressions:
         this.setSharedMessageImpressions.bind(this),
       setSharedMessageBlocked: this.setSharedMessageBlocked.bind(this),
     };
   }

   throw new Error(`Store name ${storeName} does not exist.`);
 }

 async _getStore(storeName) {
   return (await this.db).objectStore(storeName, "readwrite");
 }

 _get(storeName, key) {
   return this._requestWrapper(async () =>
     (await this._getStore(storeName)).get(key)
   );
 }

 _getAll(storeName) {
   return this._requestWrapper(async () =>
     (await this._getStore(storeName)).getAll()
   );
 }

 _getAllKeys(storeName) {
   return this._requestWrapper(async () =>
     (await this._getStore(storeName)).getAllKeys()
   );
 }

 _set(storeName, key, value) {
   return this._requestWrapper(async () =>
     (await this._getStore(storeName)).put(value, key)
   );
 }

 _openDatabase() {
   return lazy.IndexedDB.open(this.dbName, this.dbVersion, db => {
     // If provided with array of objectStore names we need to create all the
     // individual stores
     this.storeNames.forEach(store => {
       if (!db.objectStoreNames.contains(store)) {
         this._requestWrapper(() => db.createObjectStore(store));
       }
     });
   });
 }

 /**
  * Open a db (with this.dbName) if it exists. If it does not exist, create it.
  * If an error occurs, deleted the db and attempt to re-create it.
  *
  * @returns Promise that resolves with a db instance
  */
 async createOrOpenDb() {
   try {
     const db = await this._openDatabase();
     return db;
   } catch (e) {
     if (this.telemetry) {
       this.telemetry.handleUndesiredEvent({ event: "INDEXEDDB_OPEN_FAILED" });
     }
     await lazy.IndexedDB.deleteDatabase(this.dbName);
     return this._openDatabase();
   }
 }

 async _requestWrapper(request) {
   let result = null;
   try {
     result = await request();
   } catch (e) {
     if (this.telemetry) {
       this.telemetry.handleUndesiredEvent({ event: "TRANSACTION_FAILED" });
     }
     throw e;
   }

   return result;
 }

 /**
  * Gets all of the message impression data
  *
  * @returns {object|null} All multiprofile message impressions or null if error occurs
  */
 async getSharedMessageImpressions() {
   try {
     const conn = await lazy.ProfilesDatastoreService.getConnection();
     if (!conn) {
       return null;
     }
     const rows = await conn.executeCached(
       `SELECT messageId, json(impressions) AS impressions FROM MessagingSystemMessageImpressions;`
     );

     if (rows.length === 0) {
       return null;
     }

     const impressionsData = {};

     for (const row of rows) {
       const messageId = row.getResultByName("messageId");
       const impressions = JSON.parse(row.getResultByName("impressions"));

       impressionsData[messageId] = impressions;
     }

     return impressionsData;
   } catch (e) {
     lazy.ASRouterPreferences.console.error(
       `ASRouterStorage: Failed reading from MessagingSystemMessageImpressions`,
       e
     );
     if (this.telemetry) {
       this.telemetry.handleUndesiredEvent({
         event: "SHARED_DB_READ_FAILED",
       });
     }
     return null;
   }
 }

 /**
  * Gets the message blocklist
  *
  * @returns {Array|null} The message blocklist, or null if error occurred
  */
 async getSharedMessageBlocklist() {
   try {
     const conn = await lazy.ProfilesDatastoreService.getConnection();
     if (!conn) {
       return null;
     }
     const rows = await conn.executeCached(
       `SELECT messageId FROM MessagingSystemMessageBlocklist;`
     );

     return rows.map(row => row.getResultByName("messageId"));
   } catch (e) {
     lazy.ASRouterPreferences.console.error(
       `ASRouterStorage: Failed reading from MessagingSystemMessageBlocklist`,
       e
     );
     if (this.telemetry) {
       this.telemetry.handleUndesiredEvent({
         event: "SHARED_DB_READ_FAILED",
       });
     }
     return null;
   }
 }

 /**
  * Set the message impressions for a given message ID
  *
  * @param {string} messageId - The message ID to set the impressions for
  * @param {Array|null} impressions - The new value of "impressions" (an array of
  *  impression data or an emtpy array, or null to delete)
  * @returns {boolean} Success status
  */
 async setSharedMessageImpressions(messageId, impressions) {
   let success = true;
   try {
     const conn = await lazy.ProfilesDatastoreService.getConnection();
     if (!conn) {
       return false;
     }
     if (!messageId) {
       throw new Error(
         "Failed attempt to set shared message impressions with no message ID."
       );
     }

     // If impressions is falsy, delete the row (an empty array may indicate a custom
     // frequency cap; we still want to track the message ID in that case.)
     if (!impressions) {
       await conn.executeBeforeShutdown(
         "ASRouter: setSharedMessageImpressions",
         async () => {
           await conn.executeCached(
             `DELETE FROM MessagingSystemMessageImpressions WHERE messageId = :messageId;`,
             {
               messageId,
             }
           );
         }
       );
     } else {
       await conn.executeBeforeShutdown(
         "ASRouter: setSharedMessageImpressions",
         async () => {
           await conn.executeCached(
             `INSERT INTO MessagingSystemMessageImpressions (messageId, impressions) VALUES (
               :messageId,
               jsonb(:impressions)
             )
             ON CONFLICT (messageId) DO UPDATE SET impressions = excluded.impressions;`,
             {
               messageId,
               impressions: JSON.stringify(impressions),
             }
           );
         }
       );
     }

     lazy.ProfilesDatastoreService.notify();
   } catch (e) {
     lazy.ASRouterPreferences.console.error(
       `ASRouterStorage: Failed writing to MessagingSystemMessageImpressions`,
       e
     );
     if (this.telemetry) {
       this.telemetry.handleUndesiredEvent({
         event: "SHARED_DB_WRITE_FAILED",
       });
     }
     success = false;
   }

   return success;
 }

 /**
  * Adds a message ID to the blocklist and removes impressions
  * for that message ID from the impressions table when isBlocked is true
  * and deletes message ID from the blocklist when isBlocked is false
  *
  * @param {string} messageId - The message ID to set the blocked status for
  * @param {boolean} [isBlocked=true] - If the message should be blocked (true) or unblocked (false)
  * @returns {boolean} Success status
  */
 async setSharedMessageBlocked(messageId, isBlocked = true) {
   let success = true;
   if (isBlocked) {
     // Block the message, and clear impressions
     try {
       const conn = await lazy.ProfilesDatastoreService.getConnection();
       if (!conn) {
         return false;
       }
       await conn.executeTransaction(async () => {
         await conn.executeCached(
           `INSERT INTO MessagingSystemMessageBlocklist (messageId)
               VALUES (:messageId);`,
           {
             messageId,
           }
         );
         await conn.executeCached(
           `DELETE FROM MessagingSystemMessageImpressions
               WHERE messageId = :messageId;`,
           {
             messageId,
           }
         );
       });
     } catch (e) {
       lazy.ASRouterPreferences.console.error(
         `ASRouterStorage: Failed writing to MessagingSystemMessageBlocklist`,
         e
       );
       if (this.telemetry) {
         this.telemetry.handleUndesiredEvent({
           event: "SHARED_DB_WRITE_FAILED",
         });
       }
       success = false;
     }
   } else {
     // Unblock the message
     try {
       const conn = await lazy.ProfilesDatastoreService.getConnection();
       if (!conn) {
         return false;
       }
       await conn.executeBeforeShutdown(
         "ASRouter: setSharedMessageBlocked",
         async () => {
           await conn.executeCached(
             `DELETE FROM MessagingSystemMessageBlocklist WHERE messageId = :messageId;`,
             {
               messageId,
             }
           );
         }
       );
     } catch (e) {
       lazy.ASRouterPreferences.console.error(
         `ASRouterStorage: Failed writing to MessagingSystemMessageBlocklist`,
         e
       );
       if (this.telemetry) {
         this.telemetry.handleUndesiredEvent({
           event: "SHARED_DB_WRITE_FAILED",
         });
       }
       success = false;
     }
   }

   lazy.ProfilesDatastoreService.notify();
   return success;
 }
}

export function getDefaultOptions(options) {
 return { collapsed: !!options.collapsed };
}