logos-messaging-nim/library/kernel_api/protocols/store_api.nim

import std/[json, sugar]
import chronos, chronicles, results, ffi
import
  logos_delivery,
  library/utils,
  logos_delivery/waku/waku_core/message/digest,
  logos_delivery/waku/waku_store/common,
  logos_delivery/waku/common/paging,
  library/declare_lib

func fromJsonNode(jsonContent: JsonNode): Result[StoreQueryRequest, string] =
  var contentTopics: seq[string]
  if jsonContent.contains("contentTopics"):
    contentTopics = collect(newSeq):
      for cTopic in jsonContent["contentTopics"].getElems():
        cTopic.getStr()

  var msgHashes: seq[WakuMessageHash]
  if jsonContent.contains("messageHashes"):
    for hashJsonObj in jsonContent["messageHashes"].getElems():
      let hash = hashJsonObj.getStr().hexToHash().valueOr:
          return err("Failed converting message hash hex string to bytes: " & error)
      msgHashes.add(hash)

  let pubsubTopic =
    if jsonContent.contains("pubsubTopic"):
      Opt.some(jsonContent["pubsubTopic"].getStr())
    else:
      Opt.none(string)

  let paginationCursor =
    if jsonContent.contains("paginationCursor"):
      let hash = jsonContent["paginationCursor"].getStr().hexToHash().valueOr:
          return err("Failed converting paginationCursor hex string to bytes: " & error)
      Opt.some(hash)
    else:
      Opt.none(WakuMessageHash)

  let paginationForwardBool = jsonContent["paginationForward"].getBool()
  let paginationForward =
    if paginationForwardBool: PagingDirection.FORWARD else: PagingDirection.BACKWARD

  let paginationLimit =
    if jsonContent.contains("paginationLimit"):
      Opt.some(uint64(jsonContent["paginationLimit"].getInt()))
    else:
      Opt.none(uint64)

  let startTime = ?jsonContent.getProtoInt64("timeStart")
  let endTime = ?jsonContent.getProtoInt64("timeEnd")

  return ok(
    StoreQueryRequest(
      requestId: jsonContent["requestId"].getStr(),
      includeData: jsonContent["includeData"].getBool(),
      pubsubTopic: pubsubTopic,
      contentTopics: contentTopics,
      startTime: startTime,
      endTime: endTime,
      messageHashes: msgHashes,
      paginationCursor: paginationCursor,
      paginationForward: paginationForward,
      paginationLimit: paginationLimit,
    )
  )

proc waku_store_query(
    self: LogosDelivery, jsonQuery: string, peerAddr: string, timeoutMs: int32
): Future[Result[string, string]] {.ffi.} =
  let jsonContentRes = catch:
    parseJson(jsonQuery)

  if jsonContentRes.isErr():
    return err("StoreRequest failed parsing store request: " & jsonContentRes.error.msg)

  let storeQueryRequest = ?fromJsonNode(jsonContentRes.get())

  let queryResponse = (
    await self.waku.storeQuery(storeQueryRequest, peerAddr, int(timeoutMs))
  ).valueOr:
    return err("StoreRequest failed store query: " & error)

  let res = $(%*(queryResponse.toHex()))
  return ok(res) ## returning the response in json format