Documents from dapi

packages/api/src/DAPI.js

@@ -1,28 +1,98 @@
-const { Identifier } = require('dash').PlatformProtocol
+const {Identifier} = require('dash').PlatformProtocol
 
 class DAPI {
   dapi
   dpp
 
-  constructor (dapi, dpp) {
+  constructor(dapi, dpp) {
     this.dapi = dapi
     this.dpp = dpp
   }
 
-  async getIdentityBalance (identifier) {
-    const { balance } = await this.dapi.platform.getIdentityBalance(Identifier.from(identifier))
+  async getIdentityBalance(identifier) {
+    const {balance} = await this.dapi.platform.getIdentityBalance(Identifier.from(identifier))
     return balance
   }
 
-  async getTotalCredits () {
-    const { totalCreditsInPlatform } = await this.dapi.platform.getTotalCreditsInPlatform()
+  async getTotalCredits() {
+    const {totalCreditsInPlatform} = await this.dapi.platform.getTotalCreditsInPlatform()
     return totalCreditsInPlatform
   }
 
-  async getEpochsInfo (count, start, ascending) {
-    const { epochsInfo } = await this.dapi.platform.getEpochsInfo(start, count, { ascending })
+  async getEpochsInfo(count, start, ascending) {
+    const {epochsInfo} = await this.dapi.platform.getEpochsInfo(start, count, {ascending})
     return epochsInfo
   }
+
+  async getDocuments(type, documentSchemas, dataContractData, identifier, page, limit) {
+    const dataContract = await this.dpp.dataContract.createFromObject(dataContractObject)
+
+    const documentObject = {
+      $format_version: "0",
+      documentSchemas,
+      version: dataContractData.version,
+      ownerId: dataContractData.owner,
+      id: identifier
+    }
+
+    /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    let startAfter
+
+    let options = {
+      limit: page * limit > 100 ? 100 : limit,
+    }
+
+    if(page*limit>limit){
+      const cycles = Math.ceil((limit * page) / (page * limit > 100 ? 100 : limit))
+
+      for (let i = 0; i < cycles - 1; i++) {
+        if (startAfter) {
+          options.startAfter = startAfter
+        }
+
+        const docs = await this.dapi.getDocuments(
+          type,
+          documentObject,
+          options
+        )
+
+        if (docs.length === (page * limit > 100 ? 100 : limit)) {
+          startAfter = docs[docs.length - 1].getId()
+        } else {
+          return response.status(400).send({message: `out of range`})
+        }
+      }
+
+      options.limit = limit
+      const docs = await this.dapi.getDocuments(
+        type,
+        documentObject,
+        options
+      )
+
+      if (docs.length === limit) {
+        startAfter = docs[docs.length - 1].getId()
+      } else {
+        return response.status(400).send({message: `out of range`})
+      }
+    }
+
+    options = {
+      orderBy: orderData.map(el => typeof el === 'string' ? JSON.parse(el) : el),
+      limit: limit,
+    }
+
+    if (startAfter) {
+      options.startAfter = startAfter
+    }
+    /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+
+    const data = await this.dapi.platform.getDocuments(Identifier.from(dataContractObject.id), type, options)
+
+    return data.documents.map((document) =>
+      this.dpp.document.createExtendedDocumentFromDocumentBuffer(document, type, dataContract))
+  }
 }
 
 module.exports = DAPI

packages/api/src/controllers/DocumentsController.js

@@ -1,30 +1,65 @@
 const DocumentsDAO = require('../dao/DocumentsDAO')
+const DataContractsDAO = require('../dao/DataContractsDAO')
 
 class DocumentsController {
-  constructor (knex) {
+  constructor(knex, dapi) {
     this.documentsDAO = new DocumentsDAO(knex)
+    this.dataContractsDAO = new DataContractsDAO(knex)
+    this.dapi = dapi
   }
 
   getDocumentByIdentifier = async (request, response) => {
-    const { identifier } = request.params
+    const {identifier} = request.params
 
     const document = await this.documentsDAO.getDocumentByIdentifier(identifier)
 
     if (!document) {
-      response.status(404).send({ message: 'not found' })
+      return response.status(404).send({message: 'not found'})
     }
 
     response.send(document)
   }
 
   getDocumentsByDataContract = async (request, response) => {
-    const { identifier } = request.params
-    const { page = 1, limit = 10, order = 'asc' } = request.query
+    const {identifier} = request.params
+    const {page = 1, limit = 10, order = 'asc'} = request.query
 
     const documents = await this.documentsDAO.getDocumentsByDataContract(identifier, Number(page ?? 1), Number(limit ?? 10), order)
 
     response.send(documents)
   }
+
+  getDocumentsWithTypeByDataContract = async (request, response) => {
+    const {identifier, type} = request.params
+    const {page = 1, limit = 10, orderData = []} = request.query
+
+    const dataContractData = await this.dataContractsDAO.getDataContractByIdentifier(identifier)
+
+    if (!dataContractData?.schema) {
+      return response.status(404).send({message: 'not found'})
+    }
+
+    const documentsCount = await this.documentsDAO.getDocumentsCountByDataContract(identifier)
+
+    if (documentsCount !== 0 && limit * page > documentsCount) {
+      return response.status(400).send({message: `out of range (${documentsCount})`})
+    }
+
+    const documentSchemas = JSON.parse(dataContractData.schema)
+    const documentTypes = Object.keys(documentSchemas)
+
+    if (!documentTypes.includes(type)) {
+      return response.status(400).send({message: `type not found (${documentTypes.join(', ')})`})
+    }
+
+    const documents = await this.dapi.getDocuments(
+      type,
+      documentObject,
+      options
+    )
+
+    response.send(documents)
+  }
 }
 
 module.exports = DocumentsController

packages/api/src/dao/DocumentsDAO.js

@@ -2,7 +2,7 @@ const Document = require('../models/Document')
 const PaginatedResultSet = require('../models/PaginatedResultSet')
 
 module.exports = class DocumentsDAO {
-  constructor (knex) {
+  constructor(knex) {
     this.knex = knex
   }
 
@@ -77,4 +77,13 @@ module.exports = class DocumentsDAO {
 
     return new PaginatedResultSet(resultSet, page, limit, totalCount)
   }
+
+  getDocumentsCountByDataContract = async (identifier) => {
+    const [{count}] = await this.knex('documents')
+      .count('*')
+      .leftJoin('data_contracts', 'data_contracts.id', 'documents.data_contract_id')
+      .where('data_contracts.identifier', identifier)
+
+    return Number(count ?? 0)
+  }
 }

packages/api/src/routes.js

@@ -134,6 +134,21 @@ module.exports = ({
         querystring: { $ref: 'paginationOptions#' }
       }
     },
+    {
+      path: '/dataContract/:identifier/documents/:type',
+      method: 'GET',
+      handler: documentsController.getDocumentsWithTypeByDataContract,
+      schema: {
+        params: {
+          type: 'object',
+          properties: {
+            identifier: { $ref: 'identifier#' },
+            type: { type: 'string' },
+          }
+        },
+        querystring: { $ref: 'paginationOptions#' }
+      }
+    },
     {
       path: '/document/:identifier',
       method: 'GET',

packages/api/src/schemas.js

@@ -22,6 +22,9 @@ const schemaTypes = [
         type: ['string', 'null'],
         enum: ['asc', 'desc']
       },
+      orderData: {
+        type: ['array', 'null'],
+      },
       orderBy: {
         type: ['string', 'null'],
         enum: ['block_height', 'documents_count', 'tx_count', 'balance']

packages/api/src/server.js

@@ -81,7 +81,7 @@ module.exports = {
     const blocksController = new BlocksController(knex)
     const transactionsController = new TransactionsController(client, knex)
     const dataContractsController = new DataContractsController(knex)
-    const documentsController = new DocumentsController(knex)
+    const documentsController = new DocumentsController(knex, dapi)
     const identitiesController = new IdentitiesController(knex, dapi)
     const validatorsController = new ValidatorsController(knex, dapi)
     const rateController = new RateController()

packages/api/src/utils.js

@@ -1,7 +1,7 @@
 const crypto = require('crypto')
 const StateTransitionEnum = require('./enums/StateTransitionEnum')
 const net = require('net')
-const { TCP_CONNECT_TIMEOUT } = require('./constants')
+const {TCP_CONNECT_TIMEOUT} = require('./constants')
 
 const getKnex = () => {
   return require('knex')({
@@ -12,7 +12,7 @@ const getKnex = () => {
       user: process.env.POSTGRES_USER,
       database: process.env.POSTGRES_DB,
       password: process.env.POSTGRES_PASS,
-      ssl: process.env.POSTGRES_SSL ? { rejectUnauthorized: false } : false
+      ssl: process.env.POSTGRES_SSL ? {rejectUnauthorized: false} : false
     }
   })
 }
@@ -174,4 +174,4 @@ const calculateInterval = (start, end) => {
   }, intervalsInRFC[0])
 }
 
-module.exports = { hash, decodeStateTransition, getKnex, checkTcpConnect, calculateInterval }
+module.exports = {hash, decodeStateTransition, getKnex, checkTcpConnect, calculateInterval}