src/yahttp

Search:
Group by:

Types

BasicAuth = tuple[login: string, password: string]
Basic auth type 
EncodeQueryParams = object
  usePlus*: bool
  omitEq*: bool
  sep*: char
Parameters for encodeQuery procedure 
Method = enum
  GET, PUT, POST, PATCH, DELETE, HEAD, OPTIONS
Supported HTTP methods 
MultipartFile = tuple[multipartName, fileName, contentType, content: string]
Type for uploaded file 
QueryParam = tuple[key: string, value: string]
Type for URL query params 
Request = object
  url*: string
  headers*: seq[tuple[key: string, val: string]]
  httpMethod*: Method
  body*: string
Type to store request information in response 
RequestHeader = tuple[key: string, value: string]
Type for HTTP header 
Response = object
  status*: int
  body*: string
  headers*: TableRef[string, seq[string]]
  request*: Request
Type for HTTP response 
StreamingMultipartFile = tuple[name, file: string]
Type for streaming file

Procs

proc delete(url`gensym24: string;
            headers`gensym24: openArray[RequestHeader] = [];
            query`gensym24: openArray[QueryParam] = [];
    encodeQueryParams`gensym24: EncodeQueryParams = defaultEncodeQueryParams;
            body`gensym24: string = "";
            files`gensym24: openArray[MultipartFile] = [];
    streamingFiles`gensym24: openArray[StreamingMultipartFile] = [];
            auth`gensym24: BasicAuth = ("", ""); timeout`gensym24 = -1;
            ignoreSsl`gensym24 = false; sslContext`gensym24: SslContext = nil): Response {....raises: [
    LibraryError, SslError, Exception, IOError, KeyError, ValueError,
    HttpRequestError, OSError, TimeoutError, ProtocolError], tags: [RootEffect,
    ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect, TimeEffect],
    forbids: [].}
Proc for DELETE HTTP method 
proc get(url`gensym18: string;
         headers`gensym18: openArray[RequestHeader] = [];
         query`gensym18: openArray[QueryParam] = []; encodeQueryParams`gensym18: EncodeQueryParams = defaultEncodeQueryParams;
         auth`gensym18: BasicAuth = ("", ""); timeout`gensym18 = -1;
         ignoreSsl`gensym18 = false; sslContext`gensym18: SslContext = nil): Response {....raises: [
    LibraryError, SslError, Exception, IOError, KeyError, ValueError,
    HttpRequestError, OSError, TimeoutError, ProtocolError], tags: [RootEffect,
    ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect, TimeEffect],
    forbids: [].}
Proc for GET HTTP method 
proc head(url`gensym19: string;
          headers`gensym19: openArray[RequestHeader] = [];
          query`gensym19: openArray[QueryParam] = []; encodeQueryParams`gensym19: EncodeQueryParams = defaultEncodeQueryParams;
          auth`gensym19: BasicAuth = ("", ""); timeout`gensym19 = -1;
          ignoreSsl`gensym19 = false; sslContext`gensym19: SslContext = nil): Response {....raises: [
    LibraryError, SslError, Exception, IOError, KeyError, ValueError,
    HttpRequestError, OSError, TimeoutError, ProtocolError], tags: [RootEffect,
    ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect, TimeEffect],
    forbids: [].}
Proc for HEAD HTTP method 
proc html(response: Response): XmlNode {.
    ...raises: [IOError, OSError, ValueError, Exception],
    tags: [ReadIOEffect, RootEffect, WriteIOEffect], forbids: [].}
Parses response body to html 
proc json(response: Response): JsonNode {.
    ...raises: [IOError, OSError, JsonParsingError, ValueError],
    tags: [ReadIOEffect, WriteIOEffect], forbids: [].}
Parses response body to json 
proc ok(response: Response): bool {....raises: [], tags: [], forbids: [].}
Is HTTP status in OK range (> 0 and < 400)? 
proc options(url`gensym20: string;
             headers`gensym20: openArray[RequestHeader] = [];
             query`gensym20: openArray[QueryParam] = [];
    encodeQueryParams`gensym20: EncodeQueryParams = defaultEncodeQueryParams;
             auth`gensym20: BasicAuth = ("", ""); timeout`gensym20 = -1;
             ignoreSsl`gensym20 = false; sslContext`gensym20: SslContext = nil): Response {....raises: [
    LibraryError, SslError, Exception, IOError, KeyError, ValueError,
    HttpRequestError, OSError, TimeoutError, ProtocolError], tags: [RootEffect,
    ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect, TimeEffect],
    forbids: [].}
Proc for OPTIONS HTTP method 
proc patch(url`gensym23: string;
           headers`gensym23: openArray[RequestHeader] = [];
           query`gensym23: openArray[QueryParam] = [];
    encodeQueryParams`gensym23: EncodeQueryParams = defaultEncodeQueryParams;
           body`gensym23: string = "";
           files`gensym23: openArray[MultipartFile] = [];
           streamingFiles`gensym23: openArray[StreamingMultipartFile] = [];
           auth`gensym23: BasicAuth = ("", ""); timeout`gensym23 = -1;
           ignoreSsl`gensym23 = false; sslContext`gensym23: SslContext = nil): Response {....raises: [
    LibraryError, SslError, Exception, IOError, KeyError, ValueError,
    HttpRequestError, OSError, TimeoutError, ProtocolError], tags: [RootEffect,
    ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect, TimeEffect],
    forbids: [].}
Proc for PATCH HTTP method 
proc post(url`gensym22: string;
          headers`gensym22: openArray[RequestHeader] = [];
          query`gensym22: openArray[QueryParam] = []; encodeQueryParams`gensym22: EncodeQueryParams = defaultEncodeQueryParams;
          body`gensym22: string = "";
          files`gensym22: openArray[MultipartFile] = [];
          streamingFiles`gensym22: openArray[StreamingMultipartFile] = [];
          auth`gensym22: BasicAuth = ("", ""); timeout`gensym22 = -1;
          ignoreSsl`gensym22 = false; sslContext`gensym22: SslContext = nil): Response {....raises: [
    LibraryError, SslError, Exception, IOError, KeyError, ValueError,
    HttpRequestError, OSError, TimeoutError, ProtocolError], tags: [RootEffect,
    ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect, TimeEffect],
    forbids: [].}
Proc for POST HTTP method 
proc put(url`gensym21: string;
         headers`gensym21: openArray[RequestHeader] = [];
         query`gensym21: openArray[QueryParam] = []; encodeQueryParams`gensym21: EncodeQueryParams = defaultEncodeQueryParams;
         body`gensym21: string = "";
         files`gensym21: openArray[MultipartFile] = [];
         streamingFiles`gensym21: openArray[StreamingMultipartFile] = [];
         auth`gensym21: BasicAuth = ("", ""); timeout`gensym21 = -1;
         ignoreSsl`gensym21 = false; sslContext`gensym21: SslContext = nil): Response {....raises: [
    LibraryError, SslError, Exception, IOError, KeyError, ValueError,
    HttpRequestError, OSError, TimeoutError, ProtocolError], tags: [RootEffect,
    ReadDirEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect, TimeEffect],
    forbids: [].}
Proc for PUT HTTP method 
proc raiseForStatus(response: Response) {....raises: [HttpError], tags: [],
    forbids: [].}
Throws HttpError exceptions if status is 400 or above 
proc request(url: string; httpMethod: Method = Method.GET;
             headers: openArray[RequestHeader] = [];
             query: openArray[QueryParam] = [];
             encodeQueryParams: EncodeQueryParams = defaultEncodeQueryParams;
             body: string = ""; files: openArray[MultipartFile] = [];
             streamingFiles: openArray[StreamingMultipartFile] = [];
             auth: BasicAuth = ("", ""); timeout = -1; ignoreSsl = false;
             sslContext: SslContext = nil): Response {....raises: [LibraryError,
    SslError, Exception, IOError, KeyError, ValueError, HttpRequestError,
    OSError, TimeoutError, ProtocolError], tags: [RootEffect, ReadDirEffect,
    ReadEnvEffect, ReadIOEffect, WriteIOEffect, TimeEffect], forbids: [].}
Genreal proc to make HTTP request with every HTTP method 
proc to[T](response: Response; t: typedesc[T]): T
Parses response body to json and then casts it to passed type 
proc toJsonString(obj: object): string
Converts object of any type to json. Helpful to use for body argument

Made with Nim. Generated: 2025-02-26 09:21:45 UTC