Add jshttpclient

changelog.md

@@ -305,6 +305,11 @@
 
 - Added `jsconsole.dir`, `jsconsole.dirxml`, `jsconsole.timeStamp`.
 
+- Added `jshttpclient` module for JavaScript that provides
+  asyncronous `HttpClient` implemented on top of `jsfetch` and
+  synchronous `HttpClient` implemented on top of `jsxmlhttprequest`.
+  Migrated `jsxmlhttprequest` to stdlib.
+
 - Added dollar `$` and `len` for `jsre.RegExp`.
 
 - Added `std/tasks`.

lib/std/js/jsasynchttpclient.nim

@@ -0,0 +1,82 @@
+## `Async <asyncjs.html>`_ `HttpClient <httpclient.html>`_ for JavaScript implemented on top of `jsfetch <jsfetch.html>`_
+when not defined(js):
+  {.fatal: "Module jsasynchttpclient is designed to be used with the JavaScript backend.".}
+
+import std/[jsfetch, asyncjs]
+from std/uri import Uri
+
+type JsAsyncHttpClient* = ref object of JsRoot
+
+func newJsAsyncHttpClient*(): JsAsyncHttpClient = discard
+
+func fetchOptionsImpl(body: cstring; `method`: static[cstring]): FetchOptions =
+  unsafeNewFetchOptions(metod = `method`, body = body, mode = "cors".cstring, credentials = "include".cstring,
+    cache = "default".cstring, referrerPolicy = "unsafe-url".cstring, keepalive = false)
+
+proc getContent*(self: JsAsyncHttpClient; url: Uri | string): Future[cstring] {.async.} =
+  text(await fetch(cstring($url)))
+
+proc deleteContent*(self: JsAsyncHttpClient; url: Uri | string): Future[cstring] {.async.} =
+  text(await fetch(cstring($url), fetchOptionsImpl("".cstring, "DELETE".cstring)))
+
+proc postContent*(self: JsAsyncHttpClient; url: Uri | string; body = ""): Future[cstring] {.async.} =
+  text(await fetch(cstring($url), fetchOptionsImpl(body.cstring, "POST".cstring)))
+
+proc putContent*(self: JsAsyncHttpClient; url: Uri | string; body = ""): Future[cstring] {.async.} =
+  text(await fetch(cstring($url), fetchOptionsImpl(body.cstring, "PUT".cstring)))
+
+proc patchContent*(self: JsAsyncHttpClient; url: Uri | string; body = ""): Future[cstring] {.async.} =
+  text(await fetch(cstring($url), fetchOptionsImpl(body.cstring, "PATCH".cstring)))
+
+proc get*(self: JsAsyncHttpClient; url: Uri | string): Future[Response] {.async.} =
+  fetch(cstring($url))
+
+proc delete*(self: JsAsyncHttpClient; url: Uri | string): Future[Response] {.async.} =
+  fetch(cstring($url), fetchOptionsImpl("".cstring, "DELETE".cstring))
+
+proc post*(self: JsAsyncHttpClient; url: Uri | string; body = ""): Future[Response] {.async.} =
+  fetch(cstring($url), fetchOptionsImpl(body.cstring, "POST".cstring))
+
+proc put*(self: JsAsyncHttpClient; url: Uri | string; body = ""): Future[Response] {.async.} =
+  fetch(cstring($url), fetchOptionsImpl(body.cstring, "PUT".cstring))
+
+proc patch*(self: JsAsyncHttpClient; url: Uri | string; body = ""): Future[Response] {.async.} =
+  fetch(cstring($url), fetchOptionsImpl(body.cstring, "PATCH".cstring))
+
+proc head*(self: JsAsyncHttpClient; url: Uri | string): Future[Response] {.async.} =
+  fetch(cstring($url), fetchOptionsImpl("".cstring, "HEAD".cstring))
+
+
+runnableExamples("-d:nimExperimentalJsfetch -d:nimExperimentalAsyncjsThen -r:off"):
+  import std/[asyncjs, jsfetch, uri]
+
+  proc example(): Future[void] {.async.} =
+    let client = newJsAsyncHttpClient()
+    const data = """{"key": "value"}"""
+
+    block:
+      let url = parseUri("http://nim-lang.org")
+      let content = await client.getContent(url)
+      let response = await client.get(url)
+
+    block:
+      let url = parseUri("http://httpbin.org/delete")
+      let content = await client.deleteContent(url)
+      let response = await client.delete(url)
+
+    block:
+      let url = parseUri("http://httpbin.org/post")
+      let content = await client.postContent(url, data)
+      let response = await client.post(url, data)
+
+    block:
+      let url = parseUri("http://httpbin.org/put")
+      let content = await client.putContent(url, data)
+      let response = await client.put(url, data)
+
+    block:
+      let url = parseUri("http://httpbin.org/patch")
+      let content = await client.patchContent(url, data)
+      let response = await client.patch(url, data)
+
+  discard example()

lib/std/js/jshttpclient.nim

@@ -0,0 +1,5 @@
+## HttpClient for JavaScript targets.
+## * Asyncronous `HttpClient` implemented on top of `jsfetch`.
+## * Syncronous `HttpClient` implemented on top of `jsxmlhttprequest`.
+import std/js/[jsasynchttpclient, jssynchttpclient]
+export jsasynchttpclient, jssynchttpclient

lib/std/js/jssynchttpclient.nim

@@ -0,0 +1,60 @@
+## Synchronous `HttpClient <httpclient.html>`_ for JavaScript implemented on top of `jsxmlhttprequest <jsxmlhttprequest.html>`_
+when not defined(js):
+  {.fatal: "Module jssynchttpclient is designed to be used with the JavaScript backend.".}
+
+import std/uri, std/js/jsxmlhttprequest
+from std/uri import Uri
+
+type JsHttpClient* = ref object of XMLHttpRequest
+
+func newJsHttpClient*(): JsHttpClient = discard
+
+proc xmlHttpRequestImpl(self: JsHttpClient; url: Uri | string; body: string; `method`: static[cstring]): cstring =
+  self.open(`method` = `method`, url = cstring($url), false)
+  self.send(body = body.cstring)
+  self.responseText
+
+proc getContent*(self: JsHttpClient; url: Uri | string): cstring =
+  xmlHttpRequestImpl(self, url, "", "GET".cstring)
+
+proc deleteContent*(self: JsHttpClient; url: Uri | string): cstring =
+  xmlHttpRequestImpl(self, url, "", "DELETE".cstring)
+
+proc postContent*(self: JsHttpClient; url: Uri | string; body = ""): cstring =
+  xmlHttpRequestImpl(self, url, body, "POST".cstring)
+
+proc putContent*(self: JsHttpClient; url: Uri | string; body = ""): cstring =
+  xmlHttpRequestImpl(self, url, body, "PUT".cstring)
+
+proc patchContent*(self: JsHttpClient; url: Uri | string; body = ""): cstring =
+  xmlHttpRequestImpl(self, url, body, "PATCH".cstring)
+
+proc head*(self: JsHttpClient; url: Uri | string): cstring =
+  xmlHttpRequestImpl(self, url, "", "HEAD".cstring)
+
+
+runnableExamples("-r:off"):
+  from std/uri import parseUri, Uri
+
+  let client = newJsHttpClient()
+  const data = """{"key": "value"}"""
+
+  block:
+    let url = parseUri("http://nim-lang.org")
+    let content = client.getContent(url)
+
+  block:
+    let url = parseUri("http://httpbin.org/delete")
+    let content = client.deleteContent(url)
+
+  block:
+    let url = parseUri("http://httpbin.org/post")
+    let content = client.postContent(url, data)
+
+  block:
+    let url = parseUri("http://httpbin.org/put")
+    let content = client.putContent(url, data)
+
+  block:
+    let url = parseUri("http://httpbin.org/patch")
+    let content = client.patchContent(url, data)

lib/std/js/jsxmlhttprequest.nim

@@ -0,0 +1,56 @@
+## `XMLHttpRequest` for the JavaScript target: https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest
+when not defined(js):
+  {.fatal: "Module jsxmlhttprequest is designed to be used with the JavaScript backend.".}
+
+from std/dom import Node
+
+type XMLHttpRequest* = ref object of JsRoot  ## https://xhr.spec.whatwg.org
+  responseXML*: Node
+  withCredentials*: bool
+  status*, timeout*, readyState*: cint
+  responseText*, responseURL*, statusText*: cstring
+
+func newXMLHttpRequest*(): XMLHttpRequest {.importjs: "new XMLHttpRequest()".}
+  ## Constructor for `XMLHttpRequest`.
+
+func open*(this: XMLHttpRequest; `method`, url: cstring; async = true; user = cstring.default; password = cstring.default) {.importjs: "#.$1(#, #, #, #, #)".}
+  ## https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/open
+
+func send*(this: XMLHttpRequest; body: cstring | Node = cstring.default) {.importjs: "#.$1(#)".}
+  ## https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/send
+
+func abort*(this: XMLHttpRequest) {.importjs: "#.$1()".}
+  ## https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/abort
+
+func getAllResponseHeaders*(this: XMLHttpRequest): cstring {.importjs: "#.$1()".}
+  ## https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/getAllResponseHeaders
+
+func overrideMimeType*(this: XMLHttpRequest; mimeType: cstring) {.importjs: "#.$1(#)".}
+  ## https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/overrideMimeType
+
+func setRequestHeader*(this: XMLHttpRequest; key, value: cstring) {.importjs: "#.$1(#, #)".}
+  ## https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/setRequestHeader
+
+func setRequestHeader*(this: XMLHttpRequest; keyValuePairs: openArray[tuple[key, val: cstring]]) {.importjs:
+  "(() => { const rqst = #; #.forEach((item) => rqst.$1(item[0], item[1])) })()".}
+  ## Same as `setRequestHeader` but takes `openArray[tuple[key, val: cstring]]`.
+
+
+runnableExamples("-r:off"):
+  from std/dom import Node
+  let request = newXMLHttpRequest()
+  request.open("GET".cstring, "http://localhost:8000/".cstring, false)
+  request.setRequestHeader("mode".cstring, "no-cors".cstring)
+  request.setRequestHeader([(key: "mode".cstring, val: "no-cors".cstring)])
+  request.overrideMimeType("text/plain".cstring)
+  request.send()
+  echo request.getAllResponseHeaders()
+  echo "responseText\t", request.responseText
+  echo "responseURL\t", request.responseURL
+  echo "statusText\t", request.statusText
+  echo "responseXML\t", request.responseXML is Node
+  echo "status\t", request.status
+  echo "timeout\t", request.timeout
+  echo "withCredentials\t", request.withCredentials
+  echo "readyState\t", request.readyState
+  request.abort()

tools/kochdocs.nim

@@ -14,7 +14,10 @@ const
   webUploadOutput = "web/upload"
 
 var nimExe*: string
-const allowList = ["jsbigints.nim", "jsheaders.nim", "jsformdata.nim", "jsfetch.nim", "jsutils.nim"]
+const allowList = [
+  "jsbigints.nim", "jsheaders.nim", "jsformdata.nim", "jsfetch.nim", "jshttpclient.nim",
+  "jssynchttpclient.nim", "jsasynchttpclient.nim", "jsxmlhttprequest.nim", "jsutils.nim",
+]
 
 template isJsOnly(file: string): bool =
   file.isRelativeTo("lib/js") or