window.fetch polyfill for RTI

This is a fork of github/fetch with the XHR code replaced by RTI HTTP API.

How to use

You will need Promises for fetch to work. The ES6-Promise polyfill has been tested to work, but you are welcome to shop around.

Most (all?) Promise polyfills need at least setTimeout, so the file polyfill.js provides that on top of some other polyfills. All polyfills in polyfill.js are from MDN except the setTimeout polyfill which uses the RTI API.

After you include polyfill.js you can use setTimeout and clearTimeout. No setInterval or setImmediate though.

You also need a JSON polyfill if you want to use response.json().

Project setup

Include these files in you project in this order:

1. A JSON polyfill (JSON2.js seems to work)
2. polyfill.js for setTimeout() and some others
3. Your favourite Promise polyfill (maybe ES6-Promise?)
4. fetch.js

Usage

fetch() will be available globally in your project. Refer to the documentation below or on the web on how to use window.fetch.

Differences to window.fetch

HTTP Object pool

This fetch uses a pool to reuse the RTI HTTP object instances. The pool is initially empty and grows with concurrent usage. If the number of concurrent requests exceeds a configurable limit requests are deferred until an instance becomes available effectively limiting the number of concurrent requests. If the number of deferred requests exceed a configurable limit new requests will fail.

fetch.max_http_objects

Configures the maximum number of RTI HTTP object instances allowed at a time. The values of -1 and 0 are special. A positive nonzero number is the maximum number of concurrent requests after wich requests will be deferred.

The default value of -1 removes the limit. Note that you can run out of memory with this setting.

The value of 0 disables the pool usage, meaning that HTTP objects are allocated with each request and released (to the garbage collector) when the request ends. Deferring is disabled.

To set this value simply assign it in global scope.

fetch.max_http_objects = 0 // don't use pool

fetch.max_deferred_requests

Configures the maximum amount of deferred requests. The default value of -1 removes the limit. The value of 0 disables deferring requests, meaning that additional requests will fail as soon as the number of concurrent requests reaches the limit specified by fetch.max_http_objects.

To set this value simply assign it in global scope.

fetch.max_deferred_requests = 100 // prevent runaway deferring

Request option priority

You can pass a number as the priority option to a request along with the other fetch() options. The request priority is only used if the request is deferred. Requests with lower priority values will be served after the requests with higher priority. Requests with the same priority will be served in order they came in. The default priority is zero (0). You can use negative numbers for low priority.

A request with a priority of over 9000 will ignore the fetch.max_http_objects setting and if the pool is empty a new instance of the HTTP class will be created and the request will start immediately. Note that this might permanently increase the pool size as it will not be released to the GC once allocated but instead inserted into the pool.

fetch('http://example.com', { priority: 10 })
.then(...)

Request option deferTimeout

A timeout, in milliseconds, after which a deferred request waiting for an HTTP object fails. The request will be rejected with an Error.

fetch('http://example.com', { deferTimeout: 2000 })
.catch(function(error) {
  // timed out?
})

Response.xml()

This response instance method returns the response as a XML object similar to how text() and json() return the response as string or JSON object. It uses the built-in E4X XML class.

fetch('http://example.com')
.then(function(response) {
  return response.xml()
})
.then(function(xml) {
  // use xml
})

Not supported by fetch

Response.blob() and anything related is not supported since the JS engine in RTI does not support blobs and streams.

---

the rest of this document below is the unaltered original from github/fetch
Some parts of it may not apply.

---

window.fetch polyfill

The fetch() function is a Promise-based mechanism for programmatically making web requests in the browser. This project is a polyfill that implements a subset of the standard Fetch specification, enough to make fetch a viable replacement for most uses of XMLHttpRequest in traditional web applications.

This project adheres to the Open Code of Conduct. By participating, you are expected to uphold this code.

Table of Contents

• Read this first
• Installation
• Usage
  • HTML
  • JSON
  • Response metadata
  • Post form
  • Post JSON
  • File upload
  • Caveats
    • Handling HTTP error statuses
    • Sending cookies
    • Receiving cookies
    • Obtaining the Response URL
• Browser Support

Read this first

• If you believe you found a bug with how fetch behaves in Chrome or Firefox, please avoid opening an issue in this repository. This project is a polyfill, and since Chrome and Firefox both implement the window.fetch function natively, no code from this project actually takes any effect in these browsers. See Browser support for detailed information.

• If you have trouble making a request to another domain (a different subdomain or port number also constitutes as another domain), please familiarize yourself with all the intricacies and limitations of CORS requests. Because CORS requires participation of the server by implementing specific HTTP response headers, it is often nontrivial to set up or debug. CORS is exclusively handled by the browser's internal mechanisms which this polyfill cannot influence.

• If you have trouble maintaining the user's session or CSRF protection through fetch requests, please ensure that you've read and understood the Sending cookies section.

• If this polyfill doesn't work under Node.js environments, that is expected, because this project is meant for web browsers only. You should ensure that your application doesn't try to package and run this on the server.

• If you have an idea for a new feature of fetch, please understand that we are only ever going to add features and APIs that are a part of the Fetch specification. You should submit your feature requests to the repository of the specification itself, rather than this repository.

Installation

• npm install whatwg-fetch --save; or

• bower install fetch.

You will also need a Promise polyfill for older browsers. We recommend taylorhakes/promise-polyfill for its small size and Promises/A+ compatibility.

For use with webpack, add this package in the entry configuration option before your application entry point:

entry: ['whatwg-fetch', ...]

For Babel and ES2015+, make sure to import the file:

import 'whatwg-fetch'

Usage

For a more comprehensive API reference that this polyfill supports, refer to https://github.github.io/fetch/.

HTML

fetch('/users.html')
  .then(function(response) {
    return response.text()
  }).then(function(body) {
    document.body.innerHTML = body
  })

JSON

fetch('/users.json')
  .then(function(response) {
    return response.json()
  }).then(function(json) {
    console.log('parsed json', json)
  }).catch(function(ex) {
    console.log('parsing failed', ex)
  })

Response metadata

fetch('/users.json').then(function(response) {
  console.log(response.headers.get('Content-Type'))
  console.log(response.headers.get('Date'))
  console.log(response.status)
  console.log(response.statusText)
})

Post form

var form = document.querySelector('form')

fetch('/users', {
  method: 'POST',
  body: new FormData(form)
})

Post JSON

fetch('/users', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    name: 'Hubot',
    login: 'hubot',
  })
})

File upload

var input = document.querySelector('input[type="file"]')

var data = new FormData()
data.append('file', input.files[0])
data.append('user', 'hubot')

fetch('/avatars', {
  method: 'POST',
  body: data
})

Caveats

The fetch specification differs from jQuery.ajax() in mainly two ways that bear keeping in mind:

• The Promise returned from fetch() won't reject on HTTP error status even if the response is an HTTP 404 or 500. Instead, it will resolve normally, and it will only reject on network failure or if anything prevented the request from completing.

• By default, fetch won't send or receive any cookies from the server, resulting in unauthenticated requests if the site relies on maintaining a user session. See Sending cookies for how to opt into cookie handling.

Handling HTTP error statuses

To have fetch Promise reject on HTTP error statuses, i.e. on any non-2xx status, define a custom response handler:

function checkStatus(response) {
  if (response.status >= 200 && response.status < 300) {
    return response
  } else {
    var error = new Error(response.statusText)
    error.response = response
    throw error
  }
}

function parseJSON(response) {
  return response.json()
}

fetch('/users')
  .then(checkStatus)
  .then(parseJSON)
  .then(function(data) {
    console.log('request succeeded with JSON response', data)
  }).catch(function(error) {
    console.log('request failed', error)
  })

Sending cookies

To automatically send cookies for the current domain, the credentials option must be provided:

fetch('/users', {
  credentials: 'same-origin'
})

The "same-origin" value makes fetch behave similarly to XMLHttpRequest with regards to cookies. Otherwise, cookies won't get sent, resulting in these requests not preserving the authentication session.

For CORS requests, use the "include" value to allow sending credentials to other domains:

fetch('https://example.com:1234/users', {
  credentials: 'include'
})

Receiving cookies

As with XMLHttpRequest, the Set-Cookie response header returned from the server is a forbidden header name and therefore can't be programmatically read with response.headers.get(). Instead, it's the browser's responsibility to handle new cookies being set (if applicable to the current URL). Unless they are HTTP-only, new cookies will be available through document.cookie.

Bear in mind that the default behavior of fetch is to ignore the Set-Cookie header completely. To opt into accepting cookies from the server, you must use the credentials option.

Obtaining the Response URL

Due to limitations of XMLHttpRequest, the response.url value might not be reliable after HTTP redirects on older browsers.

The solution is to configure the server to set the response HTTP header X-Request-URL to the current URL after any redirect that might have happened. It should be safe to set it unconditionally.

# Ruby on Rails controller example
response.headers['X-Request-URL'] = request.url

This server workaround is necessary if you need reliable response.url in Firefox < 32, Chrome < 37, Safari, or IE.

Browser Support

• Chrome
• Firefox
• Safari 6.1+
• Internet Explorer 10+

Note: modern browsers such as Chrome, Firefox, and Microsoft Edge contain native implementations of window.fetch, therefore the code from this polyfill doesn't have any effect on those browsers. If you believe you've encountered an error with how window.fetch is implemented in any of these browsers, you should file an issue with that browser vendor instead of this project.