std/jsfetch

  Source   Edit

Note: jsfetch is Experimental. jsfetch module requires -d:nimExperimentalJsfetch

Example: cmd: -d:nimExperimentalJsfetch -r:off

import std/jsfetch
import std/[asyncjs, jsconsole, jsheaders, jsformdata]
from std/httpcore import HttpMethod
from std/jsffi import JsObject
from std/sugar import `=>`

block:
  let options0: FetchOptions = unsafeNewFetchOptions(
    metod = "POST".cstring,
    body = """{"key": "value"}""".cstring,
    mode = "no-cors".cstring,
    credentials = "omit".cstring,
    cache = "no-cache".cstring,
    referrerPolicy = "no-referrer".cstring,
    keepalive = false,
    redirect = "follow".cstring,
    referrer = "client".cstring,
    integrity = "".cstring
  )
  assert options0.keepalive == false
  assert options0.metod == "POST".cstring
  assert options0.body == """{"key": "value"}""".cstring
  assert options0.mode == "no-cors".cstring
  assert options0.credentials == "omit".cstring
  assert options0.cache == "no-cache".cstring
  assert options0.referrerPolicy == "no-referrer".cstring
  assert options0.redirect == "follow".cstring
  assert options0.referrer == "client".cstring
  assert options0.integrity == "".cstring

block:
  let options1: FetchOptions = newFetchOptions(
    metod =  HttpPost,
    body = """{"key": "value"}""".cstring,
    mode = fmNoCors,
    credentials = fcOmit,
    cache = fchNoCache,
    referrerPolicy = frpNoReferrer,
    keepalive = false,
    redirect = frFollow,
    referrer = "client".cstring,
    integrity = "".cstring
  )
  assert options1.keepalive == false
  assert options1.metod == $HttpPost
  assert options1.body == """{"key": "value"}""".cstring
  assert options1.mode == $fmNoCors
  assert options1.credentials == $fcOmit
  assert options1.cache == $fchNoCache
  assert options1.referrerPolicy == $frpNoReferrer
  assert options1.redirect == $frFollow
  assert options1.referrer == "client".cstring
  assert options1.integrity == "".cstring

block:
  let response: Response = newResponse(body = "-. .. --".cstring)
  let request: Request = newRequest(url = "http://nim-lang.org".cstring)

if not defined(nodejs):
  block:
    proc doFetch(): Future[Response] {.async.} =
      fetch "https://httpbin.org/get".cstring

    proc example() {.async.} =
      let response: Response = await doFetch()
      assert response.ok
      assert response.status == 200.cint
      assert response.headers is Headers
      assert response.body is Body

    discard example()

  when defined(nimExperimentalAsyncjsThen):
    block:
      proc example2 {.async.} =
        await fetch("https://api.github.com/users/torvalds".cstring)
          .then((response: Response) => response.json())
          .then((json: JsObject) => console.log(json))
          .catch((err: Error) => console.log("Request Failed", err))

      discard example2()

Types

FetchOptions = ref object of JsRoot
  keepalive*: bool
  metod* {.importjs: "method".}: cstring
  body*, integrity*, referrer*, mode*, credentials*, cache*, redirect*,
  referrerPolicy*: cstring
Options for Fetch API.   Source   Edit
FetchModes = enum
  fmCors = "cors", fmNoCors = "no-cors", fmSameOrigin = "same-origin"
Mode options.   Source   Edit
FetchCredentials = enum
  fcInclude = "include", fcSameOrigin = "same-origin", fcOmit = "omit"
Credential options. See https://developer.mozilla.org/en-US/docs/Web/API/Request/credentials   Source   Edit
FetchCaches = enum
  fchDefault = "default", fchNoStore = "no-store", fchReload = "reload",
  fchNoCache = "no-cache", fchForceCache = "force-cache"
https://developer.mozilla.org/docs/Web/API/Request/cache   Source   Edit
FetchRedirects = enum
  frFollow = "follow", frError = "error", frManual = "manual"
Redirects options.   Source   Edit
FetchReferrerPolicies = enum
  frpNoReferrer = "no-referrer",
  frpNoReferrerWhenDowngrade = "no-referrer-when-downgrade",
  frpOrigin = "origin", frpOriginWhenCrossOrigin = "origin-when-cross-origin",
  frpUnsafeUrl = "unsafe-url"
Referrer Policy options.   Source   Edit
Body = ref object of JsRoot
  bodyUsed*: bool
https://developer.mozilla.org/en-US/docs/Web/API/Body   Source   Edit
Response = ref object of JsRoot
  bodyUsed*, ok*, redirected*: bool
  typ* {.importjs: "type".}: cstring
  url*, statusText*: cstring
  status*: cint
  headers*: Headers
  body*: Body
https://developer.mozilla.org/en-US/docs/Web/API/Response   Source   Edit
Request = ref object of JsRoot
  bodyUsed*, ok*, redirected*: bool
  typ* {.importjs: "type".}: cstring
  url*, statusText*: cstring
  status*: cint
  headers*: Headers
  body*: Body
https://developer.mozilla.org/en-US/docs/Web/API/Request   Source   Edit

Procs

func newResponse(body: cstring | FormData): Response {.
    importjs: "(new Response(#))".}
Constructor for Response. This does not call fetch(). Same as new Response().   Source   Edit
func newRequest(url: cstring): Request {.importjs: "(new Request(#))".}
Constructor for Request. This does not call fetch(). Same as new Request().   Source   Edit
func clone(self: Response | Request): Response {.importjs: "#.$1()".}
https://developer.mozilla.org/en-US/docs/Web/API/Response/clone   Source   Edit
proc text(self: Response): Future[cstring] {.importjs: "#.$1()".}
https://developer.mozilla.org/en-US/docs/Web/API/Body/text   Source   Edit
proc json(self: Response): Future[JsObject] {.importjs: "#.$1()".}
https://developer.mozilla.org/en-US/docs/Web/API/Body/json   Source   Edit
proc formData(self: Body): Future[FormData] {.importjs: "#.$1()".}
https://developer.mozilla.org/en-US/docs/Web/API/Body/formData   Source   Edit
proc unsafeNewFetchOptions(metod, body, mode, credentials, cache, referrerPolicy: cstring;
                           keepalive: bool; redirect = "follow".cstring;
                           referrer = "client".cstring; integrity = "".cstring): FetchOptions {.importjs: "{method: #, body: #, mode: #, credentials: #, cache: #, referrerPolicy: #, keepalive: #, redirect: #, referrer: #, integrity: #}".}
Warning: Unsafe newfetchOptions.
  Source   Edit
func newfetchOptions(metod: HttpMethod; body: cstring; mode: FetchModes;
                     credentials: FetchCredentials; cache: FetchCaches;
                     referrerPolicy: FetchReferrerPolicies; keepalive: bool;
                     redirect = frFollow; referrer = "client".cstring;
                     integrity = "".cstring): FetchOptions {....raises: [],
    tags: [].}
Constructor for FetchOptions.   Source   Edit
proc fetch(url: cstring | Request): Future[Response] {.importjs: "$1(#)".}
fetch() API, simple GET only, returns a Future[Response].   Source   Edit
proc fetch(url: cstring | Request; options: FetchOptions): Future[Response] {.
    importjs: "$1(#, #)".}
fetch() API that takes a FetchOptions, returns a Future[Response].   Source   Edit
func toCstring(self: Request | Response | Body | FetchOptions): cstring {.
    importjs: "JSON.stringify(#)".}
  Source   Edit
func `$`(self: Request | Response | Body | FetchOptions): string
  Source   Edit