entity-collection-management.md

Entity/Collection Management

Related Topics

• Utilities - Data Manipulation and Normalization

Client-Only Collections

• redux-orm
  https://github.com/tommikaikkonen/redux-orm
  A small, simple and immutable ORM to manage relational data in your Redux store. Provides a Model-like interface on top of a portion of your store, allowing you to define relations between Models, store values as "tables" in your state, and make immutable updates by assigning values to Model fields.

• redux-entities-reducer
  https://github.com/luskhq/redux-entities-reducer
  A Redux reducer for handling entities

• redux-collector
  https://github.com/gtg092x/redux-collector
  Easy Collection Reducers for Redux.

• redux-simple-models
  https://github.com/mrmagooey/redux-simple-models
  Prebuilt actions, reducers, and selectors to handle storing model types

• entman
  https://github.com/Drawbotics/entman
  A simple library to manage normalizr entities in a redux store

• redux-resources
  https://github.com/travisbloom/redux-resources
  An opinionated set of reducers, actions, and selectors to manage creating, getting, listing, updating, and deleting remote resources.

• cape-redux-collection
  https://github.com/cape-io/cape-redux-collection
  Redux functions for managing lists of stuff. Collections are lists of items. This module helps manage lists of items with redux and redux-graph.

• redux-entity
  https://github.com/mikechabot/redux-entity
  redux-entity seeks to provide a scalable, predictable approach to maintaining domain entities in Redux. It's comprised of a reducer and a thunk.

• redux-normalized-entities
  https://github.com/mcollis/redux-normalized-entities
  Prewritten reducer and selectors for retrieving and updating normalized entities

• redux-async-collection
  https://github.com/QubitProducts/redux-async-collection
  Creates a reducer, immutable state and actions for an async collection

• Redux CRUD
  https://github.com/Versent/redux-crud
  Redux CRUD is a convention driven way of building CRUD applications using Redux. It gives you a standard set of action types, actions, and reducers.

• Redux Easy CRUD
  https://github.com/JacquesBonet/redux-easy-crud
  redux-easy-crud is a library based on redux-crud. It provides helper functions to speed redux crud application development.

• redux-models
  https://github.com/vshushkov/redux-models
  Models layer for Redux.

• redux-immutable-collections
  https://github.com/jcoreio/redux-immutable-collections
  Reducers and actions for storing collections of documents in Immutable.js collections in Redux state. Designed for Mongo documents, but potentially useful even if you're not using Mongo.

• crudux
  https://github.com/SpinGo/crudux
  Crudux is an attempt to dry up applications using Redux. We noticed we kept rewriting the basic entity reducers/selectors. From those applications I've distilled some basic principals into crudux. Keeps request metadata state, handles paging, doesn't mess with your entities.

• redux-patterns
  https://github.com/piersadrian/redux-patterns
  A set of actions and reducers for CRUD REST handling

• entities-reducer
  https://github.com/kwelch/entities-reducer
  Redux high order reducer for normalized flux-standard-actions. Allows for updates to entities in state. Accepts custom reducers for further control.

• redux-normalizr-utils
  https://github.com/andriichumak/redux-normalizr-utils
  A set of helpers when working with redux and normalizr. Includes a pre-written reducer to apply updates to an "entities" slice.

• erebus
  https://github.com/lab009/erebus
  Dead-simple entity API actions for Redux

• enty
  https://github.com/blueflag/enty
  Normalized Entity Management for Redux. Instead of you manually storing requested data, Enty uses schemas to describe relationships and stores the data as normalized entities.

• redux-collect
  https://github.com/cpnota/redux-collect
  A utility for converting Redux reducers, selectors, and action creators to handle a collection.

• redux-select-entities
  https://github.com/Kilix/redux-select-entities
  Simple abstraction over normalizr and reselect to handle normalized entities

• immutable-redux-relationships
  https://github.com/l2silver/immutable-redux-relationships
  Actions and handlers for immutable relationships operations

• immutable-redux-crud
  https://github.com/l2silver/immutable-redux-crud
  Actions and handlers for immutable crud operations

• redux-data-collections
  https://github.com/heygrady/redux-data-collections
  Redux actions, reducers and selectors for managing data in JSONAPI format.

• redux-entity-box
  https://github.com/haotangio/redux-entity-box
  Lightweight Redux reducer saving a lot of code spent for basic CRUD operation on normalized Redux entity state

• Redux Entities
  https://github.com/itsmepetrov/redux-entities
  Higher-order reducer for store entities received from normalizr and makes it easy to handle them.

• redux-scalable
  https://github.com/p2kmgcl/redux-scalable
  A set of reducers, selectors, middlewares and action creators that allows managing a predictable, scalable and easy to use Redux state

• redux-entity-config
  https://github.com/TheGnarCo/redux-entity-config
  Redux Entity Config provides actions and reducers to help manage entities in state (ie posts, users, etc.). Most entities require the same crud methods and are stored in a similar manner in state allowing this behavior to be extracted to a common configuration class.

• redux-entitize
  https://github.com/leoselig/redux-entitize
  Simple actions and reducers for managing entities

• normalizr-utils
  https://github.com/ascension/normalizr-utils
  A set of util/helper functions to reduce the amount of boilerplate code when working with Normalizr.

• redux-db
  https://github.com/msolvaag/redux-db
  redux-db provides a normalized redux store and easy object management. Inspired by libraries such as normalizr and redux-orm, redux-db will give a similiar workflow with a smaller footprint and no dependencies.

• redux-modular-models
  https://github.com/bobwei/redux-modular-models
  Manage models state for CRUD with ease.

• redux-entity-helpers
  https://github.com/inkOfPixel/redux-entity-helpers
  Helpers for managing normalized redux entities

• redux-crud-resources
  https://github.com/zpfled/redux-crud-resources
  Programmatically generate actions, action creators, and reducers for a given list of resources

• redux-crud-model
  https://github.com/bamlab/redux-crud-model
  Generate reducer, actions creators and selectors to easily handle entity crud operation

• redux-majic
  https://github.com/mduleone/redux-majic
  Module Architecture for JsonAPI Ingesting Consumers. Provides functions to parse JSON-API responses, and actions/reducers/selectors to interact with those entities.

• reduxsauce-crud
  https://github.com/AlexHenkel/reduxsauce-crud
  Adaptation of the reduxsauce utils to add CRUD functionality

• standard-redux-shape
  https://github.com/ecomfe/standard-redux-shape
  A tiny utility library to help you manage an optimized redux store shape.

• erschema-redux-immutable
  https://github.com/l2silver/erschema-redux-immutable
  Provides standardized actions, reducers, and state shape for storing Entities and Relationships using Immutable.js

• redux-entities-reducer
  https://github.com/jgkinnear/redux-entities-reducer
  A pre-built entities reducer that handles merging and update actions.

• redux-struct
  https://github.com/Qlean/redux-struct
  Set of tools providing a solid structure to keep and update domain entities in Redux store, including fetch status

• redux-entities
  https://github.com/fakundo/redux-entities
  Actions, reducers, and selectors for managing a collection of entities.

• redux-json-api-handlers
  https://github.com/StartupCraft/redux-json-api-handlers
  Utilities and reducers for managing JSON-API relation responses.

• redux-tide
  https://github.com/edtoken/redux-tide
  Simple library to deal with Redux normalized state, including actions and selectors

• standard-redux-shape
  https://github.com/ecomfe/standard-redux-shape
  standard-redux-shape is a tiny utility library to help you manage an optimized redux store shape, containing normalized entities and query responses with params.

• redux-schemad
  https://github.com/heiskr/redux-schemad
  Create automatic reducers, actions, and default state from a state schema. This module intentionally only supports what's necessary to follow the spirit of Avoiding Accidental Complexity When Structuring Your App State by Tal Kol.

• redux-eloquent
  https://github.com/SevenOutman/redux-eloquent
  Allows you to query and mutate your redux store in ORM style.

• crud-reducer
  https://github.com/gojutin/crud-reducer
  A simple utility library to help you manage CRUD, API or any other async operations with redux.

• blue-chip
  https://github.com/mfpiccolo/blue-chip Accepts payloads from GraphQL or JsonAPI servers, normalizes them into your store and provides an ORM like syntax for retrieving the data for use.

Client/Server Collections

• redux-collection
  https://github.com/eladlevy/redux-collection
  A robust redux collection data structure that easily syncs with a RESTful API.

• redux-crud-store
  https://github.com/devvmh/redux-crud-store
  A reusable API for syncing models with a backend. Handles async using redux-saga, implements a default reducer for models, defines action creators for the reducer, and provides selectors for models.

• json-talk
  https://github.com/manaflair/json-talk
  A Redux-friendly, JSON-API-compatible, ORM library

• redents
  https://github.com/kneradovsky/redents
  Prebuilt middleware and reducers for managing REST entity APIs, plus more.

• redux-entity
  https://github.com/gilesbradshaw/redux-entity
  A redux module allowing CRUD with real time updates

• redux-rest-adapter
  https://github.com/maksim-chekrishov/redux-rest-adapter
  A REST adapter for redux based on redux-api-middleware

• redux-rest-tools
  https://github.com/ocolot/redux-rest-tools
  Prebuilt logic for querying REST APIs

• redux-io
  https://github.com/shoutem/redux-io
  Library for easy data managing between api and redux store. Library consists of middleware, reducers and action creators that enable simple handling of data in CRUD operations with API.

• redux-jam
  https://github.com/ABASystems/redux-jam
  A Redux JSON API model layer

• Redux Clerk
  https://github.com/GetAmbassador/redux-clerk
  Redux Clerk handles the async CRUD in your Redux App. Provides a set of action creators for both async and synchronous actions, an extendable reducers, handles derived datasets and provides selectors for computing derived data, and handles optimistic updates.

• redux-supermodel
  https://github.com/MrLeebo/redux-supermodel
  Streamline the effort it takes for you to communicate between your Redux Store and a REST-like API. This is a package of action creator functions and reducers built with axios and redux-promise-middleware that handle the resource state management for you... all you need is a URL!

• react-native-redux-rest-resource
  https://github.com/Osedea/react-native-redux-rest-resource
  A helper to handle REST Apis with Redux in react-native

• redux-normalized-crud
  https://github.com/sbrigham/redux-normalized-crud
  An attempt to standardize restful calls and responses within a growing redux application

• resourceful-redux
  https://github.com/jmeas/resourceful-redux
  A system for managing 'resources': data that is persisted to remote servers.

• redux-query
  https://github.com/amplitude/redux-query
  Library for React+Redux apps to query remote data

• restful-redux
  https://github.com/jhudson8/restful-redux
  REST oriented action creators, reducers and model utilities to DRY up boilerplate XHR functionality.

• redux-retrieval
  https://github.com/zincli/redux-retrieval
  Reusable actions, reducers, selectors and sagas for retrieval/CRUD applications

• redux-asco
  https://github.com/oligus/redux-asco
  Prebuilt reducers and action creators for handling of async collections

• redux-ntities
  https://github.com/al-zah/redux-ntities
  A redux entities management library. It consists of 2 HOCs and a middleware. It allows you to persist your entities in IndexedDB/localStorage and provides common approach to save your entites in redux state.

• redux-resx
  https://github.com/fixate/redux-resx
  Yet another Redux action creators, a reducer and middleware for resource-based APIs.

• redux-entities
  https://github.com/zebulonj/redux-entities
  Abstracted support for managing persistent entities in Redux.

• redux-api-call
  https://github.com/tungv/redux-api-call
  Redux utilities for API calls using fetch with automatic race-conditions elimination. One command to create reducers, action creators and selectors for JSON API calls.

• redux-flute
  https://github.com/kyleramirez/redux-flute
  Flute is a front-end-only Object Data-store Mapping (ODM) implementation that lets you interact with RESTful APIs. By defining models on the front end and integrating closely with the popular state container, Redux, Flute offers a Ruby-on-Rails-esque, ActiveRecord-ey syntax. Think ActiveRecord for JavaScript. Flute is agnostic to back-end architecture. It's built for APIs which respond to GET/POST/POST/DELETE requests for resources identified by predefined keys.

• redux-relax
  https://github.com/saltas888/redux-relax
  A library that will help you to integrate with Redux and manage your redux state efficiently, without need of writing Actions, types, reducers, schemas(normalizr), functions for fetching data from API .

• redux-bees
  https://github.com/cantierecreativo/redux-bees
  A nice, short and declarative way to interact with JSON APIs

• redux-store-filler
  https://github.com/geoolekom/redux-store-filler
  redux-store-filler will retrieve data via API, normalize it, put it in Redux store and follow foreign keys if necessary. If data is already present in store, it will call API if only it's outdated.

• redux-crud-observable
  https://github.com/FoodMeUp/redux-crud-observable
  Actions, reducers & epics for managing crud redux state

• redux-restful-resource
  https://github.com/buhichan/redux-restful-resource
  A restful resource wrapper for typescript that auto syncs your data with redux.

• redux-endpoints
  https://github.com/dylanonelson/redux-endpoints
  Define Redux modules for fetching data from API endpoints.

• Hyperduce
  https://github.com/jondot/hyperduce
  A complete and extensible Redux workflow for handling RESTful resources. You get actions, state, and reducer out of the box for handling backend data.

• active-redux
  https://github.com/coverhound/active-redux
  The goal of this project is to stop bikeshedding API interactions on the frontend. We want an Active Record for Redux that works nicely with other reducers and doesn't require its own store.

• multi-routing-api
  https://github.com/aliaksandr-master/multi-routing-api
  Redux api middleware for separate your api routes, api actions, and interceptors. Provides state normalization, db reducer, and uses Normalizr.

• redux-chunk
  https://github.com/onlicar/redux-chunk
  A library to declaratively interact with any API. Redux Chunk allows you to define your API endpoints across chunks in webpack chunked application. For large APIs, it makes sense to dynamically add paths to your SDK-style endpoints list and it improves the separation of concerns, with each action file defining it's own endpoints and request structure. Based off of redux-bees.

• modelresource
  https://github.com/mbenadda/modelresource
  Easy-to-use model interaction methods for the client side. Uses a redux store and exposes rxjs-based methods to consumers.

• Redest
  https://github.com/momentechnologies/redest
  Rest API integration made easy - tries to solve the boilerplate that comes with communicating to a REST API.

• redux-data-entity
  https://github.com/iamawebgeek/redux-data-entity
  Helps manage Redux data easier. No action/reducer/constant declaration; caches request and prevents repetitive requests; provides optimistic creates, updates, and deletes; and has zero-config integration with no store modification.

• redux-thunk-crud
  https://github.com/gogoair/redux-thunk-crud
  A library that seeks to eliminate the boilerplate of writing highly repetitive reducers and action creators for simple RESTful API CRUD actions, using redux-thunk to handle asynchronous API calls.

• redux-crud-manager
  https://github.com/GuillaumeJasmin/redux-crud-manager
  Keep your redux store synced with your server

• hyperdux
  https://github.com/jondot/hyperdux
  A complete and extensible Redux workflow for handling RESTful resources. You get actions, state, and reducer out of the box for handling backend data.

• Reactive Record
  https://github.com/rentalutions/reactiverecord
  A front-end-only Object Data-store Mapping (ODM) implementation that lets you interact with RESTful APIs. By defining models on the front end and integrating closely with the popular state container, Redux, Reactive Record offers a Ruby-on-Rails-esque, Active Record-ey syntax

• redux-capacitor
  https://github.com/contactually/redux-capacitor
  An easy-to-use and powerful caching REST API client for React.

• r3-library
  https://github.com/cassaram09/r3-library
  r3-library (short for React-Redux-Resource) is a small library to handle resources in a React-Redux application more efficiently. This library allows users to create a Resource handles remote and promise based actions. It dynamically generates the reducer for use by the store. This project was inspired by AngularJS $Resource functionality for making HTTP requests.