feat: return processing cost for queryDocuments

node/Drive.js

@@ -62,7 +62,7 @@ class Drive {
 
   /**
    * @param {boolean} [useTransaction=false]
-   * @returns {Promise<void>}
+   * @returns {Promise<[number, number]>}
    */
   async createRootTree(useTransaction = false) {
     return driveCreateRootTreeAsync.call(this.drive, useTransaction);
@@ -72,7 +72,7 @@ class Drive {
    * @param {DataContract} dataContract
    * @param {Date} blockTime
    * @param {boolean} [useTransaction=false]
-   * @returns {Promise<void>}
+   * @returns {Promise<[number, number]>}
    */
   async applyContract(dataContract, blockTime, useTransaction = false) {
     return driveApplyContractAsync.call(
@@ -87,7 +87,7 @@ class Drive {
    * @param {Document} document
    * @param {Date} blockTime
    * @param {boolean} [useTransaction=false]
-   * @returns {Promise<void>}
+   * @returns {Promise<[number, number]>}
    */
   async createDocument(document, blockTime, useTransaction = false) {
     return driveCreateDocumentAsync.call(
@@ -106,7 +106,7 @@ class Drive {
    * @param {Document} document
    * @param {Date} blockTime
    * @param {boolean} [useTransaction=false]
-   * @returns {Promise<void>}
+   * @returns {Promise<[number, number]>}
    */
   async updateDocument(document, blockTime, useTransaction = false) {
     return driveUpdateDocumentAsync.call(
@@ -125,7 +125,7 @@ class Drive {
    * @param {string} documentType
    * @param {Identifier} documentId
    * @param {boolean} [useTransaction=false]
-   * @returns {Promise<void>}
+   * @returns {Promise<[number, number]>}
    */
   async deleteDocument(
     dataContract,
@@ -153,32 +153,37 @@ class Drive {
    * @param [query.startAfter]
    * @param [query.orderBy]
    * @param {Boolean} [useTransaction=false]
-   * @returns {Promise<Document[]>}
+   * @returns {Promise<[Document[], number]>}
    */
   async queryDocuments(dataContract, documentType, query = {}, useTransaction = false) {
     const encodedQuery = await cbor.encodeAsync(query);
 
-    const [encodedDocuments] = await driveQueryDocumentsAsync.call(
+    const [encodedDocuments, , processingFee] = await driveQueryDocumentsAsync.call(
       this.drive,
       encodedQuery,
       dataContract.id.toBuffer(),
       documentType,
       useTransaction,
     );
 
-    return encodedDocuments.map((encodedDocument) => {
+    const documents = encodedDocuments.map((encodedDocument) => {
       const [protocolVersion, rawDocument] = decodeProtocolEntity(encodedDocument);
 
       rawDocument.$protocolVersion = protocolVersion;
 
       return new Document(rawDocument, dataContract);
     });
+
+    return [
+      documents,
+      processingFee,
+    ];
   }
 
   /**
-   * @param {DataContract} dataContract
+   * @param {DataContract} identity
    * @param {boolean} [useTransaction=false]
-   * @returns {Promise<void>}
+   * @returns {Promise<[number, number]>}
    */
   async insertIdentity(identity, useTransaction = false) {
     return driveInsertIdentityAsync.call(

node/test/Drive.spec.js

@@ -195,35 +195,42 @@ describe('Drive', () => {
       await Promise.all(
         documents.map((document) => drive.createDocument(document, blockTime)),
       );
-      const fetchedDocuments = await drive.queryDocuments(dataContract, 'indexedDocument', {
+
+      const [fetchedDocuments, processingCost] = await drive.queryDocuments(dataContract, 'indexedDocument', {
         where: [['lastName', '==', 'Kennedy']],
       });
 
       expect(fetchedDocuments).to.have.lengthOf(1);
       expect(fetchedDocuments[0]).to.be.an.instanceOf(Document);
       expect(fetchedDocuments[0].toObject()).to.deep.equal(documents[4].toObject());
+
+      expect(processingCost).to.be.greaterThan(0);
     });
 
     it('should query existing documents again', async () => {
       // Create documents
       await Promise.all(
         documents.map((document) => drive.createDocument(document, blockTime)),
       );
-      const fetchedDocuments = await drive.queryDocuments(dataContract, 'indexedDocument', {
+
+      const [fetchedDocuments, processingCost] = await drive.queryDocuments(dataContract, 'indexedDocument', {
         where: [['lastName', '==', 'Kennedy']],
       });
 
       expect(fetchedDocuments).to.have.lengthOf(1);
       expect(fetchedDocuments[0]).to.be.an.instanceOf(Document);
       expect(fetchedDocuments[0].toObject()).to.deep.equal(documents[4].toObject());
+
+      expect(processingCost).to.be.greaterThan(0);
     });
 
     it('should return empty array if documents are not exist', async () => {
-      const fetchedDocuments = await drive.queryDocuments(dataContract, 'indexedDocument', {
+      const [fetchedDocuments, processingCost] = await drive.queryDocuments(dataContract, 'indexedDocument', {
         where: [['lastName', '==', 'Kennedy']],
       });
 
       expect(fetchedDocuments).to.have.lengthOf(0);
+      expect(processingCost).to.be.greaterThan(0);
     });
   });