Just a fetch() API wrapper for both Browser and Node.js.
Clone or download
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Permalink
Type Name Latest commit message Commit time
Failed to load latest commit information.
src
test
types
.babelrc
.editorconfig
.eslintrc
.gitignore
.travis.yml
README.md
index.js
karma.conf.js
package.json
webpack.config.js
yarn.lock

README.md

honoka

npm version Build Status Coverage Status

Just a fetch() API wrapper for both Browser and Node.js.

Features

  • Same as fetch() API
  • Timeout
  • Interceptors before request and response
  • Transform/convert request and response data

Installing

Using npm:

$ npm install honoka

Using cdn:

<script src="https://unpkg.com/honoka/lib/honoka.min.js"></script>

Example

Performing a GET request

// Make a request for a user with a given ID
honoka.get('/user?ID=12345')
  .then(data => {
    console.log(data);
  })
  .catch(error => {
    console.log(error);
  });

// Optionally the request above could also be done as
honoka.get('/user', {
    data: {
      ID: 12345
    }
  })
  .then(data => {
    console.log(data);
  })
  .catch(error => {
    console.log(error);
  });

Performing a POST request

honoka.post('/user', {
    data: {
      firstName: 'Fred',
      lastName: 'Flintstone'
    }
  })
  .then(data => {
    console.log(data);
  })
  .catch(error => {
    console.log(error);
  });

honoka API

Requests can be made by passing the relevant config to honoka.

honoka(options)
// Send a POST request
honoka('/user/12345', {
  method: 'post',
  data: {
    firstName: 'Fred',
    lastName: 'Flintstone'
  }
});
honoka(url[, options])
// Send a GET request (default method)
honoka('/user/12345');

Request method aliases

For convenience aliases have been provided for all supported request methods.

honoka.get(url[, options])
honoka.delete(url[, options])
honoka.head(url[, options])
honoka.options(url[, options])
honoka.post(url[, options])
honoka.put(url[, options])
honoka.patch(url[, options])

Request Config

These are the available config options for making requests. Same as fetch() API.

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

  // `headers` are custom headers to be sent
  headers: {'X-Requested-With': 'XMLHttpRequest'},

  // `data` are the URL parameters or post body to be sent
  data: {
    ID: 12345
  },

  // `baseURL` will be prepended to `url` unless `url` is absolute.
  baseURL: 'https://some-domain.com/api/',

  // `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,

  // `dataType` indicates the type of data that the server will respond with
  // options are 'arraybuffer', 'blob', 'buffer', 'json', 'text', 'auto'
  dataType: 'auto', // default

  // Authentication credentials mode
  // https://developer.mozilla.org/en-US/docs/Web/API/Request/credentials
  credentials: 'omit', // default


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

Config Defaults

You can specify config defaults that will be applied to every request.

Global Defaults

honoka.defaults.baseURL = 'https://example.com/api';
honoka.defaults.timeout = 10e3;
honoka.defaults.method = 'get';
honoka.defaults.headers.post['Content-Type'] = 'application/json';

Interceptors

You can intercept requests or responses before they are handled by then.

const unregister = honoka.interceptors.register({
  request: options => {
    // Modify the options here
    const token = localStorage.getItem('token');
    if (token) {
      options.headers['X-JWT-Token'] = token;
    }
    return options;
  },
  response: (data, response) => {
    // Check responseData here
    if (data.status && data.status !== 'success') {
      alert('request error');
    }
    // Modify the data & response object
    return [data, response];
  }
})

// Unregister your interceptor
unregister();

Abort Operation

You can cancel a pending request manually by using AbortController.

let abortController = new AbortController(),
    signal = abortController.signal;

honoka('/100MBtest.bin', { signal })
  .then((res) => {
    console.log(res)
  })
  .catch((err) => {
    console.log(err);
  });

setTimeout(() => {
  abortController.abort();
}, 2000);

Promises

honoka depends on a native ES6 Promise implementation to be supported.
If your environment doesn't support ES6 Promises, you can polyfill.

TypeScript

honoka includes TypeScript definitions.

import honoka from 'honoka';
honoka.get('/user?ID=12345');

Changelog

For changelogs, see Release Notes.

License

MIT