Source: storage-wallet.js

  1. import DockWallet from './dock-wallet';
  3. /** The Dock Wallet which loads, adds, removes and queries contents in an EDV */
  4. class StorageWallet extends DockWallet {
  5.   constructor(id, storageInterface) {
  6.     super(id);
  8.     this.promises = [];
  9.     this.storageInterface = storageInterface;
  10.   }
  12.   add(content) {
  13.     super.add(content);
  14.     this.promises.push(this.insertToStorage(content));
  15.   }
  17.   remove(contentId) {
  18.     super.remove(contentId);
  19.     this.promises.push(this.removeFromStorage(contentId));
  20.   }
  22.   update(content) {
  23.     super.update(content);
  24.     this.promises.push(this.updateInStorage(content));
  25.   }
  27.   async query(search) {
  28.     // tODO: query the in memory contents first and pass flag to not use it, if empty run storage search
  29.     // Query storage interface and map into wallet contents
  30.     const { documents } = await this.storageInterface.find(search);
  31.     return documents.map((document) => document.content);
  32.   }
  34.   async load() {
  35.     // Find all documents, storage interfaces should return all docs when no params supplied
  36.     const { documents } = await this.storageInterface.find();
  38.     // Format to wallet contents
  39.     if (documents) {
  40.       documents.forEach((document) => super.add(document.content));
  41.     }
  42.     return this.contents;
  43.   }
  45.   async updateInStorage(content) {
  46.     const documentResult = await this.getStorageDocument(content);
  47.     await this.storageInterface.update({
  48.       document: {
  49.         ...documentResult,
  50.         content,
  51.       },
  52.     });
  53.   }
  55.   async insertToStorage(content) {
  56.     // Attempt to insert the document to the storage interface
  57.     // if the promise fails, then the content will be removed and error re-thrown
  58.     try {
  59.       await this.storageInterface.insert({
  60.         document: {
  61.           content,
  62.         },
  63.       });
  64.     } catch (e) {
  65.       super.remove(content.id);
  66.       throw e;
  67.     }
  68.   }
  70.   async removeFromStorage(id) {
  71.     await this.storageInterface.delete({
  72.       document: await this.getStorageDocument({ id }),
  73.     });
  74.   }
  76.   async getStorageDocument({ id }) {
  77.     // Find the storage document by the content ID
  78.     // some interfaces may just return the same document, but some need custom structures
  79.     const { documents } = await this.storageInterface.find({
  80.       equals: {
  81.         'content.id': id,
  82.       },
  83.     });
  85.     // Delete first result from storage
  86.     if (documents.length) {
  87.       return documents[0];
  88.     } else {
  89.       throw new Error(`Unable to find storage document by content.id: ${id}`);
  90.     }
  91.   }
  93.   async sync() {
  94.     // A user will call this method to ensure storage interface requests finish
  95.     // we do this because wallet doesnt always require blocking operations
  96.     // depending on the storage interface used
  97.     const { promises } = this;
  98.     this.promises = [];
  99.     if (promises.length) {
  100.       await Promise.all(promises);
  101.     }
  102.   }
  103. }
  105. export default StorageWallet;