HTTP Requests

Overview

Use the informat.http object to perform network request operations. HTTP requests are implemented based on axios(0.27.2).

Notes

HTTP requests are initiated through the browser, which may cause cross-origin issues. These can be resolved in the following ways:

• Configure the requested service to include cross-origin headers
• Modify the request URL to call Informat's API or automation, and use automation and scripts to forward the request
• Modify the request URL to call a load balancer proxy (nginx, haproxy) and forward the request through the proxy

request

Send a network request

informat.http.request(config);

Request Configuration Description

{
  // `url` is the server URL used for the request
  url: '/user',

  // `method` is the request method to be used when making the request
  method: 'get', // default

  // `baseURL` will be prepended to `url` unless `url` is absolute.
  // It can be convenient to set `baseURL` for an axios instance to pass relative URLs to methods of that instance.
  baseURL: 'https://some-domain.com/api/',

  // `transformRequest` allows changes to the request data before it is sent to the server
  // This is only applicable for request methods 'PUT', 'POST', 'PATCH' and 'DELETE'
  // The last function in the array must return a string, Buffer instance, ArrayBuffer, FormData, or Stream
  // You can modify the headers object.
  transformRequest: [function (data, headers) {
    // Do whatever you want to transform the data

    return data;
  }],

  // `transformResponse` allows changes to the response data to be made before it is passed to then/catch
  transformResponse: [function (data) {
    // Do whatever you want to transform the data

    return data;
  }],

  // Custom headers to be sent
  headers: {'X-Requested-With': 'XMLHttpRequest'},

  // `params` are the URL parameters to be sent with the request
  // Must be a plain object or a URLSearchParams object
  params: {
    ID: 12345
  },

  // `paramsSerializer` is an optional function in charge of serializing `params`
  // (e.g. https://www.npmjs.com/package/qs, http://api.jquery.com/jquery.param/)
  paramsSerializer: function (params) {
    return Qs.stringify(params, {arrayFormat: 'brackets'})
  },

  // `data` is the data to be sent as the request body
  // Only applicable for request methods 'PUT', 'POST', 'DELETE', and 'PATCH'
  // When no `transformRequest` is set, must be of one of the following types:
  // - string, plain object, ArrayBuffer, ArrayBufferView, URLSearchParams
  // - Browser only: FormData, File, Blob
  // - Node only: Stream, Buffer
  data: {
    firstName: 'Fred'
  },
  
  // Alternative syntax to send data as request body
  // Request method post
  // Only the value is sent, not the key
  data: 'Country=Brasil&City=Belo Horizonte',

  // `timeout` specifies the number of milliseconds before the request times out.
  // If the request takes longer than `timeout`, the request will be aborted.
  timeout: 1000, // default is `0` (no timeout)

  // `withCredentials` indicates whether or not cross-site Access-Control requests should be made using credentials
  withCredentials: false, // default

  // `adapter` allows custom handling of requests which makes testing easier.
  // Returns a promise and supplies a valid response (see lib/adapters/bpmn2.md).
  adapter: function (config) {
    /* ... */
  },

  // `auth` indicates that HTTP Basic auth should be used, and supplies credentials.
  auth: {
    username: 'janedoe',
    password: 's00pers3cret'
  },

  // `responseType` indicates the type of data that the server will respond with
  // options are: 'arraybuffer', 'document', 'json', 'text', 'stream'
  // Browser only: 'blob'
  responseType: 'json', // default

  // `responseEncoding` indicates encoding to use for decoding responses (Node.js only)
  // Note: Ignored for `responseType` of 'stream' or client-side requests
  responseEncoding: 'utf8', // default

  // `xsrfCookieName` is the name of the cookie to use as a value for xsrf token
  xsrfCookieName: 'XSRF-TOKEN', // default

  // `xsrfHeaderName` is the name of the http header that carries the xsrf token value
  xsrfHeaderName: 'X-XSRF-TOKEN', // default

  // `onUploadProgress` allows handling of progress events for uploads
  // Browser only
  onUploadProgress: function (progressEvent) {
    // Do whatever you want with the native progress event
  },

  // `onDownloadProgress` allows handling of progress events for downloads
  // Browser only
  onDownloadProgress: function (progressEvent) {
    // Do whatever you want with the native progress event
  },

  // `maxContentLength` defines the max size of the http response content in bytes allowed in node.js
  maxContentLength: 2000,

  // `maxBodyLength` (Node only) defines the max size of the http request content in bytes allowed
  maxBodyLength: 2000,

  // `validateStatus` defines whether to resolve or reject the promise for a given HTTP response status code.
  // If `validateStatus` returns `true` (or is set to `null` or `undefined`), the promise will be resolved;
  // otherwise, the promise will be rejected.
  validateStatus: function (status) {
    return status >= 200 && status < 300; // default
  },

  // `maxRedirects` defines the maximum number of redirects to follow in node.js.
  // If set to 0, no redirects will be followed.
  maxRedirects: 5, // default

  // `socketPath` defines a UNIX Socket to be used in node.js.
  // e.g. '/var/run/docker.sock' to send requests to the docker daemon.
  // Only one of `socketPath` or `proxy` can be specified.
  // If both are specified, `socketPath` is used.
  socketPath: null, // default

  // `httpAgent` and `httpsAgent` define a custom agent to be used when performing http
  // and https requests, respectively, in node.js. This allows options to be added like
  // `keepAlive` that are not enabled by default.
  httpAgent: new http.Agent({ keepAlive: true }),
  httpsAgent: new https.Agent({ keepAlive: true }),

  // `proxy` defines the hostname, port, and protocol of the proxy server.
  // You can also define your proxy using the conventional `http_proxy` and `https_proxy` environment variables.
  // Use `false` to disable proxies, ignoring environment variables.
  // `auth` indicates that HTTP Basic auth should be used to connect to the proxy, and supplies credentials.
  // This will set a `Proxy-Authorization` header, overwriting any existing `Proxy-Authorization` custom headers you have set using `headers`.
  // If the proxy server uses HTTPS, you must set the protocol to `https`
  proxy: {
    protocol: 'https',
    host: '127.0.0.1',
    port: 9000,
    auth: {
      username: 'mikeymike',
      password: 'rapunz3l'
    }
  },

  // see https://axios-http.com/zh/docs/cancellation
  cancelToken: new CancelToken(function (cancel) {
  }),

  // `decompress` indicates whether or not the response body should be decompressed 
  // automatically. If set to `true` will also remove the 'content-encoding' header 
  // from the responses objects of all decompressed responses
  // - Node only (XHR cannot turn off decompression)
  decompress: true // default

}

get

Send GET request

informat.http.get(url, config)

Parameter	Type	Description
url	String	Request URL
config	Object	Request configuration

Return Value Promise

informat.http.get('/user', {
  params: {
    ID: 12345
  }
})
.then(function (response) {
  console.log(response);
})
.catch(function (error) {
  console.log(error);
})
.then(function () {
  // Always executed
});

delete

Send DELETE request

informat.http.delete(url, config)

Parameter	Type	Description
url	String	Request URL
config	Object	Request configuration

Return Value Promise

informat.http.delete('/user/12345')

head

Send HEAD request

informat.http.head(url, config)

Parameter	Type	Description
url	String	Request URL
config	Object	Request configuration

Return Value Promise

informat.http.head('/user/12345')

options

Send OPTIONS request

informat.http.options(url, config)

Parameter	Type	Description
url	String	Request URL
config	Object	Request configuration

Return Value Promise

informat.http.options('/user/12345')

post

Send POST request

informat.http.post(url, data, config)

Parameter	Type	Description
url	String	Request URL
data	Object	Request body data
config	Object	Request configuration

Return Value Promise

informat.http.post('/user', {
  firstName: 'Fred',
  lastName: 'Flintstone'
})
.then(function (response) {
  console.log(response);
})
.catch(function (error) {
  console.log(error);
});

put

Send PUT request

informat.http.put(url, data, config)

Parameter	Type	Description
url	String	Request URL
data	Object	Request body data
config	Object	Request configuration

Return Value Promise

informat.http.put('/user/12345', {
  firstName: 'Fred',
  lastName: 'Flintstone'
})
.then(function (response) {
  console.log(response);
})
.catch(function (error) {
  console.log(error);
});

patch

Send PATCH request

informat.http.patch(url, data, config)

Parameter	Type	Description
url	String	Request URL
data	Object	Request body data
config	Object	Request configuration

Return Value Promise

informat.http.patch('/user/12345', {
  firstName: 'Fred'
})
.then(function (response) {
  console.log(response);
})
.catch(function (error) {
  console.log(error);
});

all

Send multiple concurrent requests

informat.http.all(iterable)

Parameter	Type	Description
iterable	Iterable	Array of request objects

Return Value Promise

function getUserAccount() {
  return informat.http.get('/user/12345');
}

function getUserPermissions() {
  return informat.http.get('/user/12345/permissions');
}

informat.http.all([getUserAccount(), getUserPermissions()])
.then(informat.http.spread(function (acct, perms) {
  // Both requests are now complete
}));

spread

Method for expanding array arguments into multiple arguments

informat.http.spread(callback)

Parameter	Type	Description
callback	Function	Callback function

Return Value Promise

// Usage example:
informat.http.all([getUserAccount(), getUserPermissions()])
.then(informat.http.spread(function (acct, perms) {
  // Both requests are now complete
}));