• Stars
    star
    241
  • Rank 163,692 (Top 4 %)
  • Language
    JavaScript
  • Created over 9 years ago
  • Updated over 8 years ago

Reviews

There are no reviews yet. Be the first to send feedback to the community and the maintainers!

Repository Details

Streamlined Flux abstract interface suitable for a variety of backends.

Nexus Flux

Abstract Nexus Flux Diagram

    +-> Action.dispatch ---+--> Client.Events ---+--> Action.onDispatch -+
    |    Fire & forget             Stream                 Callback       |
Component logic         Adapter               Adapter               Global logic
    |      Callback                Stream               Fire & forget    |
    +-- Store.onUpdate  <--+--- Server.Events <--+------ Store.update ---+

Local Nexus Flux Diagram

Component #1 <---+
                 |
Component #2 <---+-- LocalAdapter -> Global logic
                 |
Component #3 <---+

Over the wire Nexus Flux Diagram using Websockets (with socket.io fallback)

in the browser        socket.io frames     in the server

Component #A1 <---+
                  |
Component #A2 <---+-- SocketIOAdapter -+
                  |      Client A      |
Component #A3 <---+                    |
                                       +-> Global logic
Component #B1 <---+                    |
                  |                    |
Component #B2 <---+-- SocketIOAdapter -+
                  |      Client B
Component #B3 <---+

Off-thread Flux using WebWorkers

in the main thread   postMessage frames  in the webworker
Component #1 <---+
                 |
Component #2 <---+-- WebWorkerAdapter -> Global logic
                 |
Component #3 <---+

Principles

Nexus Flux abstracts the concepts of Facebook's Flux architecture to its most general form:

  • 'Clients' can subscribe to Stores updates, and dispatch Actions with a payload
  • 'Server' handles Actions and update Stores.

The Client/Server abstraction is merely an abstraction. The traditional, in-browser-memory Flux implementation, is done purely on the (Internet) Client side. However, this abstraction allows to conceive Flux more rigorously and more importantly, to implement Flux over the Wire trivially.

This representation of Flux enforces immutable Stores and asynchronous communication. Acknowledging that Flux communication is asycnhronous upfront avoid the pain of mindlessly wrapping everything in setImmediate on top of a synchronous implementation.

Nexus Flux provides an abstract implementation that takes away all boilerplate calls such as registering and unregistering callbacks, dealing with events directly, etc, and lets you focus on two things: your components logic and your global logic.

Nexus Flux is built with React, Nexus Uplink and React Nexus in mind, but it is not tied to any of these projects and can be used a standalone library.

Use cases

Nexus Flux is designed with the following use cases in mind:

  • Implementing Flux over the Wire: dispatch actions from clients and propagate store updates to all connected clients in real time, efficiently.

  • Expose an isomorphic environment to an app: initialize a local flux on the server using the request object, or in the browser using the window object, and abstract it away.

  • Defer expensive calculations off the main thread: fetch raw collections from a remote cache, filter & retreat locally without blocking the main UI thread.

Client usage example (in a React view)

{
  getInitialState() {
    this.lifespan = new Lifespan();
    return {
      todoList: this.props.flux.Store('/todo-list', this.lifespan).value,
    };
  }

  componentWillMount() {
    this.props.flux.Store('/todo-list', this.lifespan)
    .onUpdate(({ head }) => this.setState({ todoList: head }))
    .onDelete(() => this.setState({ todoList: void 0 }));
    this.removeItem = this.props.flux.Action('/remove-item', this.lifespan).dispatch;
  }

  componentWillUnmount() {
    this.lifespan.release();
  }

  render() {
    return this.state.todoList ? todoList.map((item, name) =>
      <div onClick={() => this.removeItem({ name })}>
        {item.get('description')} (Click to remove)
      </div>
    ) : null;
  }
}

Server usage example

const todoList = server.Store('/todo-list', myApp.lifespan);
const removeItem = server.Action('/remove-item', myApp.lifespan);

todoList
.set('first', { description: 'My first item' })
.set('second', { description: 'My second item' })
.set('third', { description: 'My third item' })
.commit();

removeItem.onDispatch((clientID, { name }) => {
  todoList.delete(name).commit();
});

Traditional local flux using nexus-flux/adapters/Local

This implements the orthodox Flux for in-app data propagation.

import { Server, Client } from 'nexus-flux/adapters/Local';
const server = new Server();
const client = new Client(server);
// use the server and client instance like above.

Flux over the wire using nexus-flux-socket.io

Share global server-side app state across all connected clients.

// Client side: runs in the browser or in a node process
import Client from 'nexus-flux-socket.io/client';
const client = Client('http://localhost:8080'));
// Server side: runs in a node process, which may or may not be the same process
import Server from 'nexus-flux-socket.io/server';
const server = new Server(8080);

In browser, off-thread local flux using nexus-flux/adapters/Worker

Defer expensive app-state data calculations off the main thread to avoid blocking UI. No black magic, just clever message passing.

// Client side: runs in the main thread
import { Client } from 'nexus-flux/adapters/Worker';
const worker = new Worker('my-web-worker.js');
const client = new Client(worker);
// Server side: runs in the webworker
import { Server } from 'nexus-flux/adapters/Worker';
const server = new Server(self);

Cross-window flux using nexus-flux-xwindow (TBD)

Communicate between windows from the same origin using the flux architecture.

// Client side: runs in the child window
import { Client } from 'nexus-flux/adapters/XWindow';
const client = new Client(window.parent);
// Server side: runs in the parent window
import { Server } from 'nexus-flux/adapters/XWindow';
const server = new Server(window);

Node-to-node TCP flux using nexus-flux-node (TBD)

Communicate between node servers using the flux architecture.

// Client side: runs in a node process
import { Client } from 'nexus-flux/adapters/TCP';
const client = new Client('192.168.0.1', 8080);
// Server side: runs in a node process, which may or may not be the same process
import { Server } from 'nexus-flux/adapters/TCP';
const server = new Server(8080);

Implement your own adapter!

If you think of a communication channel where Flux would be relevant, you can implement your own adapter.

The LocalAdapter and WebworkerAdapter sources should provide helpful guidance for doing so.

Usage

This module is written in ES6/7. You will need babel to run it.

More Repositories

1

react-armor

Protect your DOM from third-party tampering.
JavaScript
636
star
2

coding-styles

My coding styles.
398
star
3

react-animate

React animation mixin.
JavaScript
271
star
4

remutable

Like Immutable, but actually Mutable with diffs and versions.
JavaScript
222
star
5

fastify-zod

Zod integration with Fastify
TypeScript
188
star
6

react-prepare

Prepare you app state for async server-side rendering and more!
JavaScript
100
star
7

directus-typescript-gen

JavaScript
84
star
8

react-traverse

React Components Magic
JavaScript
70
star
9

nexus-flux-socket.io

socket.io adapter for Nexus Flux, implementing Flux over the Wire.
JavaScript
53
star
10

react-rails-starterkit

Starter repository for React on Rails. Fork it!
JavaScript
47
star
11

typed-assert

A typesafe TS assertion library
TypeScript
47
star
12

react-css

Converts plain CSS into (optionally auto-prefixed) React-style properties map.
JavaScript
35
star
13

es6-starterkit

The future is today!
JavaScript
33
star
14

useless

Useless React hooks
TypeScript
32
star
15

react-query

React Virtual DOM querying made easy.
JavaScript
30
star
16

react-statics-styles

Declarative styles in React components with support for pre- and post-processing.
JavaScript
26
star
17

react-nexus-chat

Demo chat app using React Nexus.
CSS
18
star
18

react-styling-demo

Demos for react-animate, react-css and other React styling demos.
JavaScript
17
star
19

react-defer

React Mixin for dealing with defers/timeouts/intervals/requestAnimationFrame with less boilerplate.
JavaScript
16
star
20

react-nexus-starterkit

React Nexus Starterkit Project. Clone/fork, hack, deploy!
JavaScript
12
star
21

node-async-context

Node Async Context Monitoring & Isolation
JavaScript
8
star
22

immutable-request

Isomorphic cacheable and cancellable HTTP request than return Promise for Immutable.Map.
JavaScript
8
star
23

lifespan

Unifying callbacks removals.
JavaScript
7
star
24

typed-jest-expect

Elegant jest.expect typings for a more civilized age
TypeScript
7
star
25

isomorphic-router

Tiny, lightweight isomorphic router.
JavaScript
6
star
26

gulp-react-statics-styles

Gulp task for react-statics-styles.
JavaScript
5
star
27

tween-interpolate

Extra lightweight generic and CSS values interpolators and tweens.
JavaScript
5
star
28

typed-react-openapi

Idiomatic, strongly typed React OpenAPI integration
TypeScript
5
star
29

hypernode

Ideas and prototypes for Hypernode, a scalable, distributed JS node environment.
JavaScript
4
star
30

react-transform-props

React Component decorator for transforming props
JavaScript
4
star
31

nexus-uplink-simple-server

Nexus Uplink Simple Server (for Node).
JavaScript
4
star
32

react-nexus-app

React Nexus App skeleton.
JavaScript
4
star
33

nexus-uplink-client

Nexus Uplink Client (isomorphic).
JavaScript
4
star
34

algebraic-effects-experiments

Experiments with algebraic effects
JavaScript
3
star
35

react-esi-poc

JavaScript
3
star
36

typecheck-decorator

Runtime arguments validation as ES7 decorators.
JavaScript
3
star
37

virtual

Userland virtual methods and abstract classes for ES6.
JavaScript
3
star
38

typed-result

A liberal reinterpretation of the Result type for TypeScript
TypeScript
3
star
39

lisa-db

TypeScript
2
star
40

react-maybe-state

React Mixin for maybe getting state (defaulting to null).
JavaScript
2
star
41

otter-den

TypeScript
2
star
42

snippets

Snippets of code to copy/paste.
TypeScript
2
star
43

react-ml

JavaScript
2
star
44

http-exceptions

HTTP Exceptions with err codes.
JavaScript
2
star
45

lisa-prototype

TypeScript
2
star
46

react-nexus-todomvc

React Nexus obligatory TodoMVC. (WORK IN PROGRESS)
JavaScript
2
star
47

react-lambda

Higher order and functional utilies for manipulating React components
JavaScript
2
star
48

react-http

Universal HTTP client for use in React applications.
JavaScript
2
star
49

rotenberg.io

My homepage
Lua
1
star
50

RktTools

Wow RktTools addon
Lua
1
star
51

backend-starterkit

Node Koa/postgresql backend starterkit
JavaScript
1
star
52

typed-utilities

Strongly typed general purpose utilities
TypeScript
1
star
53

wow-scripts

Lua
1
star
54

typed-ref

TypeScript
1
star
55

wow-workbench

TypeScript
1
star
56

react-identicon

React Component for Gravatar identicons.
JavaScript
1
star
57

mindstorms-utilities

Utilities for Lego Mindstorms
JavaScript
1
star
58

netlify-cms-toolkit

Tools and utilities for Netlify CMS
TypeScript
1
star
59

nexus-events

Yet Another EventEmitter. Sane callbacks removals.
JavaScript
1
star
60

lodash-next

An extension of lodash for next level js.
JavaScript
1
star
61

remembrall-pi

Python
1
star
62

mindlogger-node

TypeScript
1
star
63

nexus-flux-rest

Nexus Flux backend using plain HTTP requests (REST-like).
JavaScript
1
star
64

workbench

JavaScript
1
star
65

where-did-i-put-it

One button to find them all
TypeScript
1
star
66

node-pg-container

Postgres containers for Node
TypeScript
1
star
67

react-ml-editor

ReactML editor with live preview and suggest-completion.
JavaScript
1
star