react-request-block
TypeScript icon, indicating that this package has built-in type declarations

0.2.3 • Public • Published

react-request-block

React component to compose requests within your components, with support for server-side rendered requests.

Install

Via npm:

npm install -S react-request-block

Via Yarn:

yarn add react-request-block

How to use

react-request-block was built with a focus on simplicity and flexibility, and with out-of-the-box support for use within server-side rendering frameworks (more on that below).

RequestBlockProvider

The basic wrapper that provides caching for the nested RequestBlock instances and the ability to provide a default origin to prepend onto the RequestBlock urls.

Properties

Property Default Description
cache new RequestBlockCache RequestBlockCache instance for caching request made per provider. By default, a fresh cache instance is created if one is not supplied.
options null Default options to be included with each request made by a RequestBlock. Can be ignored by adding ignoreContextOptions to RequestBlock instances.
origin '' Default origin to prepend to RequestBlock requests. Defaults to the current site’s protocol/host.
renderPromises null This is used strictly for server-side rendering instances. In most cases you shouldn’t worry about setting this, unless you need to. In which case, it accepts a RenderPromises instance.

RequestBlock

The RequestBlock is what you will be interacting with most. It makes it really easy to compose requests into your pages and components and handles all the caching for you behind the scenes. A simple alternative to achieving a similar thing with redux/react-redux.

Properties

Property Default Description
url null URL to make request to. If origin specified on RequestBlockProvider, url will be appended to it.
options null Options to include with fetch request made. All normal fetch options accepted.
parser (data, props) => data Method for manipulating the response payload before it is applied to the data value. Handy for stripping out unwanted stuff, or making it more useable for your page or component.
skip false Whether or not the request should be skipped during server-side rendering.
ignoreContextOptions false Flag to ignore options set on the RequestBlockProvider for requests being made by RequestBlock.
onRequest ({ data, error, fetched, loading }) => {} Callback made when a request is initiated.
onLoad ({ data, error, fetched, loading }) => {} Callback made when request has successfull completed.
onError ({ data, error, fetched, loading }) => {} Callback made when a request encounters an error.

withRequestBlock (HOC)

Provides access to the current context of the ReactRequestBlock. Context passed to the wrapped component includes:

Properties

Property Type Description
cache RequestBlockCache The current RequestBlockCache instance being used by the provider.
options object null
origin string Origin to prepend to urls being requested by RequestBlock instances.
renderPromises RenderPromises RenderPromises instance set for use during server-side rendering.

Examples

Below are a few examples of using the RequestBlockProvider and two ways you can use the RequestBlock.

RequestBlockProvider

import React from 'react';
import { RequestBlockCache, RequestBlockProvider } from 'react-request-block';
import Page from './Page';  // @see Page component defined in `RequestBlock` example below
 
const App = () => (
  <RequestBlockProvider>
    <Router>
      <Switch>
        <Route path="/:slug*" component={Page} />
      </Switch>
    </Router>
  </RequestBlockProvider>
);
 
export default App;

RequestBlock (wrapping content)

In this example, the RequestBlock components allows you to structure requests right into your pages or components.

import React from 'react';
import { RequestBlock } from 'react-request-block';
 
const Page = (props) => (
  <RequestBlock url="[your endpoint here]">
    {({data, error, fetched, loading}) => {
      if (loading || !fetched) {
        return null;
      }
 
      if (error) {
        console.error(error);
        return null;
      }
 
      if (!data) {
        return <p>Page does not exist.</p>;
      }
 
      // See the Contentful query response
      console.debug(data);
 
      // Process and pass in the loaded `data` necessary for your page or child components.
      return (
        ...
      );
    }}
  </RequestBlock>
);
 
export default Page;

RequestBlock (w/ callbacks)

import React, { Component } from 'react';
import { RequestBlock } from 'react-request-block';
 
class Page extends Component {
  constructor(props) {
    super(props);
 
    this.state = {
      loading: false,
      data: null,
      error: null,
    };
 
    this.onRequest = this.onRequest.bind(this);
    this.onLoad = this.onLoad.bind(this);
    this.onError = this.onError.bind(this);
  }
 
  onRequest() {
    this.setState({
      loading: true,
    });
  }
 
  onLoad({ data }) {
    this.setState({
      loading: false,
      data,
    });
  }
 
  onError({ error }) {
    this.setState({
      loading: false,
      error,
    });
  }
 
  render() {
    return (
      <React.Fragment>
        <RequestBlock
          url="[your endpoint here]"
          onRequest={this.onRequest}
          onLoad={this.onLoad}
          onError={this.onError}
        />
        {loading && <p>Loading...</p>}
        {error && <p>{error}</p>}
        {data && [something that uses data]}
      </React.Fragment>
    );
  }
}
 
export default Page;

Using Next.js?

If you like what you see above, you might like next-request-block, which lets you easily add react-request-block to your Next.js app. Making it easy to ensure that all your RequestBlock instances render awesomely server-side.

License

MIT © Ryan Hefner

Package Sidebar

Install

npm i react-request-block

Weekly Downloads

2

Version

0.2.3

License

MIT

Unpacked Size

207 kB

Total Files

35

Last publish

Collaborators

  • ryanhefner