component-data-fetching-preloading.md

Component Data Fetching And Preloading

• react-composer
  https://github.com/kadirahq/react-komposer
  Creates React container components that know how to fetch data from arbitrary data sources, including Promises, RxJS observables, Meteor's Tracker, or Redux stores

• Adrenaline
  https://github.com/gyzerok/adrenaline
  Adrenaline intend to provide you Relay-like ability to describe your components with declarative data requirements, while keeping API as simple as possible. You are free to use it with different libraries like Redux, React Router and etc.

• redux-falcor
  https://github.com/ekosz/redux-falcor
  redux-falcor helps connect your Redux applications to your Falcor API.

• redux-loader
  https://github.com/Versent/redux-loader
  A high order component and request management utility for Redux. Loads resources and passes them to the child components via props. Keeps tracks of requests already done and avoids duplicate requests.

• react-reach
  https://github.com/kennetpostigo/react-reach
  react-reach is designed to be used along side redux and react. React-reach works as the layer that handles communication of data between React and graphQL. Reach enables developers to make queries and mutations against GraphQL.

• firedux
  https://github.com/adjohnson916/firedux
  Wraps the Firebase JavaScript API to dispatch Redux actions that optimisically & immediately read/write to an in-memory subset of your data from Firebase, then asynchronously pull & push data in the background.

• AutoAction
  https://github.com/tonyhb/autoaction
  Declarative data loading and action calling within react-redux

• redux-preheat
  https://github.com/mikew/redux-preheat
  A helpful decorator to run Redux actions in universal React apps with support for Promises.

• GroundControl
  https://github.com/raisemarketplace/ground-control
  GroundControl simplifies React-Router/Redux single page applications. Organizes reducers based on route structure, and builds application state & replaces reducers on transition. Data fetching API to control when to render components & manage client / server differences (Universal API).

• ReduxAsyncConnect
  https://github.com/Rezonans/redux-async-connect
  It allows you to request async data, store them in redux state and connect them to your react component.

• redux-connect
  https://github.com/makeomatic/redux-connect
  Fork and refactor of redux-async-connect

• Redux Data Loader
  https://github.com/kouhin/redux-dataloader
  Loads async data for Redux apps focusing on preventing duplicated requests and dealing with async dependencies. Deeply inspired by Alt Data Sources API, also inspired by redux-saga.

• redux-filter
  https://github.com/nsmith7989/redux-filter
  Higher Order React Component for filtering (and sorting) a collection of items. This is especially useful in product filters that mimic the sorting/filtering behavior of Amazon or Best Buy.

• Redux Connected PropTypes
  https://github.com/conorhastings/redux-connected-proptypes
  Redux Connected PropTypes consumes a React Component(with propTypes) and returns a connected version of that component in react-redux parlance with the props defined on the compoents propTypes injected into the component instance from the redux global state.

• react-redux-resolve
  https://github.com/martijndeh/react-redux-resolve
  Experimental library to universally resolve your component's initial data. Per component you can specify a resolver. On the client side, the resolver is executed in componentDidMount() and on the server-side once you call waitForResolves(renderProps, store). This makes server-side rendering easy to implement

• react-gql
  https://github.com/leeching/react-gql
  A collection of helper functions to build a react app with redux and graphql.

• Relate
  https://github.com/relax/relate
  Relate is a library built to use together with Redux and GraphQL. You can think of it as an alternative to Relay for Redux. It extends the React Redux's connect where you can additionally specify your container's data needs. Relate will resolve each container data needs automatically and provides it to each one the data they requested.

• redux-async-props
  https://github.com/AlastairTaft/redux-async-props
  A simple way to load props and state asynchonously with react-router and redux.

• react-reflorp
  https://github.com/tomat/react-reflorp
  A simple ORM using React Refetch as a backend, but the data is stored in the Redux store.

• redux-taxi
  https://github.com/nytimes/redux-taxi
  ReduxTaxi allows for component-driven asynchronous server-side rendering in isomorphic/universal React+Redux apps.

• redux-data
  https://github.com/dmin/redux-data
  Redux-Data is a companion to Redux that allows you to declare the data (i.e. records from your server) that your application uses. Redux-Data helps you query and cache data as well as perform mutations on the data.

• redux-fetch-data
  https://github.com/nordsoftware/redux-fetch-data
  Redux utility library for fetching data using promises on both server and client

• redial
  https://github.com/markdalgleish/redial
  Universal data fetching and route lifecycle management for React.

• react-refetch
  https://github.com/heroku/react-refetch
  A simple, declarative, and composable way to fetch data for React components

• react-relay-redux
  https://github.com/Aweary/react-relay-redux
  Redux integration for Relay. react-relay-redux lets you listen and respond to Relay queries and mutations using Redux actions and reducers.

• Roulade
  https://github.com/nerdgrass/roulade
  Roulade is a library to enable React & Redux applications to easily work with GraphQL servers.

• react-redux-pledge
  https://github.com/PCreations/react-redux-pledge
  Enhance your redux-connected component by rendering them only when their props are guaranteed (i.e, relative data are fetched)

• react-redux-promise
  https://github.com/rainforestapp/async-state-components
  A set of tools to link react component to the lifecycle of a promise

• react-redux-universal-resolver
  https://github.com/Tarabyte/react-redux-universal-resolver
  Yet another universal redux based higher order component for React

• redux-data-fetching
  https://github.com/alanzanattadev/redux-data-fetching
  Automatic data managment with caching and auto merging of cached data and fetched one, based on GraphQL.

• redux-resource-manager
  https://github.com/rolyatmax/redux-resource-manager
  A Redux wrapper that helps manage external resources in a client-side application.

• redux-async-loader
  https://github.com/recruit-tech/redux-async-loader
  Async data loader for Redux apps with React-Router.

• react-redux-fetch
  https://github.com/hirviid/react-redux-fetch
  A declarative and customizable way to fetch data for React components and manage that data in the Redux state.

• redux-fetch
  https://github.com/flowcommerce/redux-fetch
  Redux Fetch provides universal data fetching bindings for applications built with React, React Router, and Redux.

• redux-saga-fetcher
  https://github.com/ntkoso/redux-saga-fetcher
  redux-saga-fetcher is an universal data fetching library for Redux Saga and React Router.

• redux-lazy-props
  https://github.com/markshlick/redux-lazy-props
  Lazy fetching of data for connected components.

• async-props
  https://github.com/manaflair/async-props
  Easy React/Redux data preload

• graphdux
  https://github.com/Mobelux/graphdux
  A graphql/redux integration toolkit

• falcor-provider
  https://github.com/jameslaneconkling/falcor-provider
  Redux provider to connect your falcor graph to your redux store

• redux-router-preload
  https://github.com/babotech/redux-router-preload
  Universal preloading for redux-router

• subscription-container
  https://github.com/remedux/subscription-container
  A React component that dispatches start and stop Redux actions to drive a meteor subscription

• hoc-data-redux
  https://github.com/krzysztof4M/hoc-data-redux
  Higher Order Component for fetching initial data in Redux

• redux-wait-for-action
  https://github.com/Chion82/redux-wait-for-action
  Redux middleware to make store.dispatch() return a promise which will be resolved when another specified action is dispatched, which is useful for universal(isomorphic) React Web Apps with redux and server-side rendering.

• redux-promise-wait
  https://github.com/nealgranger/redux-promise-wait
  An indispensable tool for rendering Redux apps on the server. Uses a store enhancer to run a callback function repeatedly until the Redux store state settles when all chains of asynchronous actions have resolved.

• redux-universal
  https://github.com/reducks/redux-universal
  A Redux store enhancer taking care of promise resolution for building universal apps.

• react-graphql-redux
  https://github.com/youknowriad/react-graphql-redux
  This library allows you to use GraphQL to query your Redux store

• link-redux
  https://github.com/fletcher91/link-redux
  Linked Data Rendering for humans, on React/Redux. Use this to enable Link in React. It provides components to build data-independent semantic applications for the human consumption of linked data with React and Redux.

• fetch-data
  https://github.com/unfold/fetch-data
  Declarative data fetching for Redux and React.

• redux-promise-counter
  https://github.com/bitgenics/redux-promise-counter
  Keep track of unresolved promises in Redux Actions. Useful for Server Side Rendering.

• tectonic
  https://github.com/tonyhb/tectonic
  A declarative REST data loader for React/Redux

• react-quest
  https://github.com/djgrant/redux-quest
  Declarative data fetching for universal React/Redux apps.

• redux-query
  https://github.com/amplitude/redux-query
  A library for querying and managing network state in React/Redux applications. Lets you declare your network dependencies right next to your React components.

• react-prepare
  https://github.com/elierotenberg/react-prepare
  react-prepare allows you to have you deeply nested components with asynchronous dependencies, and have everything just work with server-side rendering.

• redux-async-load
  https://github.com/Pop-Code/redux-async-load
  This module merges the logic of loading data on the client side and the server side.

• redux-ready
  https://github.com/djgrant/redux-ready
  Enhances your redux store with a store.ready() method, which resolves once all promises dispatched into the store are fulfilled. Very handy for server rendering redux applications that initialise with async actions.

• react-arc
  https://github.com/Sunny-fr/react-arc
  React Abstract Redux Component: A set of components to manage collection or model from a REST service

• redux-hydration
  https://github.com/jessedrelick/redux-hydration
  A combination of a Redux Reducer, a HOC for dynamically loading components, and a declarative way to define what Redux actions are needed to resolve state prior to sending to the finally rendered view to the client.

• redux-preload
  https://github.com/blueberryapps/redux-preload
  Preload actions on both server & client side (allows deep nesting of components)

• redux-fetchers
  https://github.com/LIQIDTechnology/redux-fetchers
  Automatic action dispatching and caching for Redux. Let components automatically fetch their needed data.

• redux-autoloader
  https://github.com/woltapp/redux-autoloader
  A higher order component for declarative data loading in React and Redux.

• artemisajs
  https://github.com/javierfernandes/artemisajs
  Artemisa extends React+Redux with the ability to model interaction with the backend (aka fetches) in a declarative way, reducing boilerplate code and providing a framework with (potential) functionality on the local storage and sync of the data with the back (cache).

• motel
  https://github.com/greim/motel
  Motel is an implementation of the data vacancy pattern, which simplifies data-fetching in Flux-style apps. It was designed with Redux in mind, but can be used in any model-view-update app.

• redux-preload
  https://github.com/BTMPL/redux-preload
  A small loader HoC that helps you defer the rendering of your Components until an (asynchronous) action or actions finish.

• react-redux-component-init
  https://github.com/mediamonks/react-redux-component-init
  A library to manage react component initialization in isomorphic applications using Redux

• redux-fetch-on-mount
  https://github.com/orzarchi/redux-fetch-on-mount
  A higher order component that performs a redux action when the wrapped component is mounted

• redux-api-react-switch
  https://github.com/xurei/redux-api-react-switch
  A set of React components to show different content based on the state of a resource fetch. It is meant to be used with redux-api, but it can be used with any other library.

• redux-refetch
  https://github.com/scwe/redux-refetch
  A simple automated data refetcher for using react-redux. The basic use case is when you have some data that needs to be refetched anytime there is a change in some of the underlying properties.

• redux-collect-promises
  https://github.com/zumb/redux-collect-promises
  Collect redux promises and wait for resolution for server side rendering

• redux-async-fetcher
  https://github.com/wing-eu/redux-async-fetcher
  ReduxAsyncFetcher is used to extract data fetching logic from your component lifecycle.

• redux-anity
  https://github.com/sseppola/redux-anity
  Handle data dependencies declaratively. The idea is to stop writing data fetching in your components, and instead make the middleware do the work.

• fetch-hoc-redux
  https://github.com/rvlewerissa/fetch-hoc-redux
  Simple Fetching Higher Order Component with Redux integration. It will cache your fetch automatically.

• react-redux-fetch-if-necessary
  https://github.com/carpeliam/react-redux-fetch-if-necessary
  Higher order component for managing the concern of making sure your dependencies are loaded before you render

• redux-universal-render
  https://github.com/StefanoPastore/redux-universal-render
  Redux module for universal render with async fetching data.

• redux-infuse
  https://github.com/meruhealth/redux-infuse
  Simple way to manage data loading from APIs into Redux state and into connected components.

• react-apollo-redux
  https://github.com/Drawbotics/react-apollo-redux
  A small wrapper to automatically dispatch actions in response to apollo mutations.

• tpt-connect
  https://github.com/TeachersPayTeachers/tpt-connect
  TpT-Connect is a Redux extension which creates simple interfaces for your React components' to interact with your RESTful API. TpT-Connect automatically fetches your components' data dependencies on componentWillMount and componentDidUpdate when relevant props are changed so you don't have to worry about when and how to fetch your data. To make your resources available across multiple components, TpT-Connect normalizes and caches your resources in its Redux state.

• redux-obtain
  https://github.com/robertsonmcclure/redux-obtain
  redux-obtain works with React Redux to coordinate getting data from a server using React component lifecycles to manage the asychronous actions and Redux to store all of its state.