Redux Middleware

packages/ae-redux/README.md

@@ -0,0 +1,3 @@
+# @algebraic-effects/effects
+A collection of effects to use while writing your program with algebraic effects in javascript
+

packages/ae-redux/build/Store.js

@@ -0,0 +1,59 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _core = require("@algebraic-effects/core");
+
+var _utils = require("@algebraic-effects/utils");
+
+var _utils2 = require("./utils");
+
+var Store = (0, _core.createEffect)('Store', {
+  dispatch: (0, _core.func)(['action']),
+  getState: (0, _core.func)([], 'state'),
+  selectState: (0, _core.func)(['?state -> a'], 'a'),
+  getAction: (0, _core.func)([], 'action'),
+  waitFor: (0, _core.func)(['actionType | Action -> Boolean'])
+});
+
+Store.of = function (_ref) {
+  var _ref$store = _ref.store,
+      _dispatch = _ref$store.dispatch,
+      _getState = _ref$store.getState,
+      action = _ref.action;
+  return Store.handler({
+    dispatch: function dispatch(_ref2) {
+      var resume = _ref2.resume;
+      return (0, _utils.compose)(resume, _dispatch, _utils2.decorateAction);
+    },
+    getState: function getState(_ref3) {
+      var resume = _ref3.resume;
+      return (0, _utils.compose)(resume, _getState);
+    },
+    selectState: function selectState(_ref4) {
+      var resume = _ref4.resume;
+      return function (fn) {
+        return (0, _utils.compose)(resume, fn || _utils.identity, _getState)();
+      };
+    },
+    getAction: function getAction(_ref5) {
+      var resume = _ref5.resume;
+      return function () {
+        return resume(action);
+      };
+    },
+    waitFor: function waitFor(_ref6) {
+      var resume = _ref6.resume,
+          end = _ref6.end;
+      return function (filter) {
+        return (0, _utils2.filterAction)(filter, action) ? resume(action) : end(action);
+      };
+    }
+  });
+};
+
+var _default = Store;
+exports.default = _default;

packages/ae-redux/build/index.js

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "Store", {
+  enumerable: true,
+  get: function get() {
+    return _Store.default;
+  }
+});
+exports.createEffectsMiddleware = void 0;
+
+var _Store = _interopRequireDefault(require("./Store"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var createEffectsMiddleware = function createEffectsMiddleware(program, handler) {
+  var middleware = function middleware(store) {
+    return function (next) {
+      return function (action) {
+        _Store.default.of({
+          store: store,
+          action: action
+        }).with(handler).run(program).fork(console.error, console.log);
+
+        return next(action);
+      };
+    };
+  };
+
+  return middleware;
+};
+
+exports.createEffectsMiddleware = createEffectsMiddleware;

packages/ae-redux/build/utils.js

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.filterAction = exports.isEffectfulAction = exports.decorateAction = exports.AE_REDUX_ACTION = void 0;
+
+var _utils = require("@algebraic-effects/utils");
+
+var AE_REDUX_ACTION = (0, _utils.createSymbol)('algebraic-effects/redux-action');
+exports.AE_REDUX_ACTION = AE_REDUX_ACTION;
+
+var decorateAction = function decorateAction(action) {
+  action && (action.$$type = AE_REDUX_ACTION);
+  return action;
+};
+
+exports.decorateAction = decorateAction;
+
+var isEffectfulAction = function isEffectfulAction(action) {
+  return action ? action.$$type === AE_REDUX_ACTION : false;
+};
+
+exports.isEffectfulAction = isEffectfulAction;
+
+var filterAction = function filterAction(filter, action) {
+  if (!action) return false;
+  if (isEffectfulAction(action)) return false;
+  if (typeof filter === 'string') return filter === action.type;
+  if (typeof filter === 'function') return filter(action);
+  return false;
+};
+
+exports.filterAction = filterAction;

packages/ae-redux/index.js

@@ -0,0 +1 @@
+module.exports = require('./build/index');

packages/ae-redux/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@algebraic-effects/redux",
+  "version": "0.0.2",
+  "description": "Redux middleware to allow using algebraic effects to write your actions",
+  "main": "index.js",
+  "isBuildTarget": true,
+  "repository": "https://github.com/phenax/algebraic-effects",
+  "author": "Akshay Nair <[email protected]>",
+  "license": "MIT",
+  "dependencies": {
+    "@algebraic-effects/core": "0.0.2"
+  },
+  "keywords": [
+    "functional",
+    "algebraic",
+    "effects",
+    "generators",
+    "fp",
+    "redux",
+    "saga",
+    "middleware"
+  ],
+  "peerDependencies": {
+    "redux": "^4.0.1"
+  }
+}

packages/ae-redux/src/Store.js

@@ -0,0 +1,21 @@
+import { createEffect, func } from '@algebraic-effects/core';
+import { compose, identity } from '@algebraic-effects/utils';
+import { decorateAction, filterAction } from './utils';
+
+const Store = createEffect('Store', {
+  dispatch: func(['action']),
+  getState: func([], 'state'),
+  selectState: func(['?state -> a'], 'a'),
+  getAction: func([], 'action'),
+  waitFor: func(['actionType | Action -> Boolean']),
+});
+
+Store.of = ({ store: { dispatch, getState }, action }) => Store.handler({
+  dispatch: ({ resume }) => compose(resume, dispatch, decorateAction),
+  getState: ({ resume }) => compose(resume, getState),
+  selectState: ({ resume }) => fn => compose(resume, fn || identity, getState)(),
+  getAction: ({ resume }) => () => resume(action),
+  waitFor: ({ resume, end }) => filter => filterAction(filter, action) ? resume(action) : end(action),
+});
+
+export default Store;

packages/ae-redux/src/index.js

@@ -0,0 +1,15 @@
+import Store from './Store';
+
+export { Store };
+
+export const createEffectsMiddleware = (program, handler) => {
+  const middleware = store => next => action => {
+    Store.of({ store, action })
+      .with(handler)
+      .run(program)
+      .fork(console.error, console.log);
+    return next(action);
+  };
+
+  return middleware;
+};

packages/ae-redux/src/utils.js

@@ -0,0 +1,19 @@
+
+import { createSymbol } from '@algebraic-effects/utils';
+
+export const AE_REDUX_ACTION = createSymbol('algebraic-effects/redux-action');
+
+export const decorateAction = action => {
+  action && (action.$$type = AE_REDUX_ACTION);
+  return action;
+};
+
+export const isEffectfulAction = action => action ? action.$$type === AE_REDUX_ACTION : false;
+
+export const filterAction = (filter, action) => {
+  if (!action) return false;
+  if (isEffectfulAction(action)) return false;
+  if (typeof filter === 'string') return filter === action.type;
+  if (typeof filter === 'function') return filter(action);
+  return false;
+};