Build

dist/es5/http/fetch.js

@@ -0,0 +1,43 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});
+
+exports['default'] = function (fetch) {
+    return function (config) {
+        var url = config.url;
+        delete config.url;
+
+        if (config.data) {
+            config.body = /application\/json/.test(config.headers['Content-Type']) ? JSON.stringify(config.data) : config.data;
+            delete config.data;
+        }
+
+        return fetch(url, config).then(function (response) {
+            return response.json().then(function (json) {
+                var headers = {};
+
+                response.headers.forEach(function (value, name) {
+                    headers[name] = value;
+                });
+
+                var responsePayload = {
+                    data: json,
+                    headers: headers,
+                    statusCode: response.status
+                };
+
+                if (response.status >= 200 && response.status < 300) {
+                    return responsePayload;
+                }
+
+                var error = new Error(response.statusText);
+                error.response = responsePayload;
+                throw error;
+            });
+        });
+    };
+};
+
+module.exports = exports['default'];

dist/es5/http/request.js

@@ -0,0 +1,52 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});
+
+exports['default'] = function (request) {
+    return function (config) {
+        if (config.data) {
+            config.form = /application\/json/.test(config.headers['Content-Type']) ? JSON.stringify(config.data) : config.data;
+            delete config.data;
+        }
+
+        if (config.params) {
+            config.qs = config.params;
+            delete config.params;
+        }
+
+        return new Promise(function (resolve, reject) {
+            request(config, function (err, response, body) {
+                if (err) {
+                    throw err;
+                }
+
+                var data = undefined;
+
+                try {
+                    data = JSON.parse(body);
+                } catch (e) {
+                    data = body;
+                }
+
+                var responsePayload = {
+                    data: data,
+                    headers: response.headers,
+                    statusCode: response.statusCode
+                };
+
+                if (response.statusCode >= 200 && response.statusCode < 300) {
+                    return resolve(responsePayload);
+                }
+
+                var error = new Error(response.statusMessage);
+                error.response = responsePayload;
+
+                reject(error);
+            });
+        });
+    };
+};
+
+module.exports = exports['default'];

dist/es5/index.js

@@ -0,0 +1,45 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
+
+var _modelEndpoint = require('./model/endpoint');
+
+var _modelEndpoint2 = _interopRequireDefault(_modelEndpoint);
+
+var _httpFetch = require('./http/fetch');
+
+var _httpFetch2 = _interopRequireDefault(_httpFetch);
+
+var _serviceHttp = require('./service/http');
+
+var _serviceHttp2 = _interopRequireDefault(_serviceHttp);
+
+var _modelDecorator = require('./model/decorator');
+
+var _httpRequest = require('./http/request');
+
+var _httpRequest2 = _interopRequireDefault(_httpRequest);
+
+var _modelScope = require('./model/scope');
+
+var _modelScope2 = _interopRequireDefault(_modelScope);
+
+exports['default'] = function (baseUrl, httpBackend) {
+    var rootScope = (0, _modelScope2['default'])();
+    rootScope.assign('config', 'entityIdentifier', 'id');
+    rootScope.set('debug', false);
+    if (!baseUrl && typeof window !== undefined && window.location) {
+        rootScope.set('url', window.location.protocol + '//' + window.location.host);
+    } else {
+        rootScope.set('url', baseUrl);
+    }
+
+    return (0, _modelDecorator.member)((0, _modelEndpoint2['default'])((0, _serviceHttp2['default'])(httpBackend))(rootScope));
+};
+
+exports.fetchBackend = _httpFetch2['default'];
+exports.requestBackend = _httpRequest2['default'];

dist/es5/model/decorator.js

@@ -0,0 +1,66 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});
+exports.custom = custom;
+exports.collection = collection;
+exports.member = member;
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
+
+var _objectAssign = require('object-assign');
+
+var _objectAssign2 = _interopRequireDefault(_objectAssign);
+
+function custom(endpoint) {
+    return function (name) {
+        var relative = arguments.length <= 1 || arguments[1] === undefined ? true : arguments[1];
+
+        if (relative) {
+            return member(endpoint['new'](endpoint.url() + '/' + name)); // eslint-disable-line no-use-before-define
+        }
+
+        return member(endpoint['new'](name)); // eslint-disable-line no-use-before-define
+    };
+}
+
+function collection(endpoint) {
+    function _bindHttpMethod(method) {
+        return function () {
+            var _endpoint$new;
+
+            for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
+                args[_key] = arguments[_key];
+            }
+
+            var id = args.shift();
+            return (_endpoint$new = endpoint['new'](endpoint.url() + '/' + id))[method].apply(_endpoint$new, args);
+        };
+    }
+
+    return (0, _objectAssign2['default'])(endpoint, {
+        custom: custom(endpoint),
+        'delete': _bindHttpMethod('delete'),
+        getAll: endpoint.get,
+        get: _bindHttpMethod('get'),
+        head: _bindHttpMethod('head'),
+        one: function one(name, id) {
+            return member(endpoint['new'](endpoint.url() + '/' + name + '/' + id));
+        }, // eslint-disable-line no-use-before-define
+        patch: _bindHttpMethod('patch'),
+        put: _bindHttpMethod('put')
+    });
+}
+
+function member(endpoint) {
+    return (0, _objectAssign2['default'])(endpoint, {
+        all: function all(name) {
+            return collection(endpoint['new'](endpoint.url() + '/' + name));
+        },
+        custom: custom(endpoint),
+        one: function one(name, id) {
+            return member(endpoint['new'](endpoint.url() + '/' + name + '/' + id));
+        }
+    });
+}

dist/es5/model/endpoint.js

@@ -0,0 +1,147 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
+
+var _objectAssign = require('object-assign');
+
+var _objectAssign2 = _interopRequireDefault(_objectAssign);
+
+var _response = require('./response');
+
+var _response2 = _interopRequireDefault(_response);
+
+var _immutable = require('immutable');
+
+var _utilSerialize = require('../util/serialize');
+
+var _utilSerialize2 = _interopRequireDefault(_utilSerialize);
+
+/* eslint-disable new-cap */
+
+exports['default'] = function (request) {
+    return function endpointFactory(scope) {
+        scope.on('error', function () {
+            return true;
+        }); // Add a default error listener to prevent unwanted exception
+        var endpoint = {}; // Persists reference
+
+        function _generateRequestConfig(method, data, params, headers) {
+            var config = (0, _immutable.Map)({
+                errorInterceptors: (0, _immutable.List)(scope.get('errorInterceptors')),
+                headers: (0, _immutable.Map)(scope.get('headers')).mergeDeep((0, _immutable.Map)(headers)),
+                method: method,
+                params: params,
+                requestInterceptors: (0, _immutable.List)(scope.get('requestInterceptors')),
+                responseInterceptors: (0, _immutable.List)(scope.get('responseInterceptors')),
+                url: scope.get('url')
+            });
+
+            if (data) {
+                if (!config.hasIn(['headers', 'Content-Type'])) {
+                    config = config.setIn(['headers', 'Content-Type'], 'application/json;charset=UTF-8');
+                }
+
+                config = config.set('data', (0, _immutable.fromJS)(data));
+            }
+
+            scope.emit('request', (0, _utilSerialize2['default'])(config));
+
+            return config;
+        }
+
+        function _onResponse(config, rawResponse) {
+            var response = (0, _response2['default'])(rawResponse, endpoint);
+            scope.emit('response', response, (0, _utilSerialize2['default'])(config));
+            return response;
+        }
+
+        function _onError(config, error) {
+            scope.emit('error', error, (0, _utilSerialize2['default'])(config));
+            throw error;
+        }
+
+        function _httpMethodFactory(method) {
+            var expectData = arguments.length <= 1 || arguments[1] === undefined ? true : arguments[1];
+
+            if (expectData) {
+                return function (data) {
+                    var params = arguments.length <= 1 || arguments[1] === undefined ? null : arguments[1];
+                    var headers = arguments.length <= 2 || arguments[2] === undefined ? null : arguments[2];
+
+                    var config = _generateRequestConfig(method, data, params, headers);
+                    return request(config).then(function (rawResponse) {
+                        return _onResponse(config, rawResponse);
+                    }, function (rawResponse) {
+                        return _onError(config, rawResponse);
+                    });
+                };
+            }
+
+            return function () {
+                var params = arguments.length <= 0 || arguments[0] === undefined ? null : arguments[0];
+                var headers = arguments.length <= 1 || arguments[1] === undefined ? null : arguments[1];
+
+                var config = _generateRequestConfig(method, null, params, headers);
+                return request(config).then(function (rawResponse) {
+                    return _onResponse(config, rawResponse);
+                }, function (error) {
+                    return _onError(config, error);
+                });
+            };
+        }
+
+        function addInterceptor(type) {
+            return function (interceptor) {
+                scope.push(type + 'Interceptors', interceptor);
+
+                return endpoint;
+            };
+        }
+
+        (0, _objectAssign2['default'])(endpoint, {
+            addErrorInterceptor: addInterceptor('error'),
+            addRequestInterceptor: addInterceptor('request'),
+            addResponseInterceptor: addInterceptor('response'),
+            'delete': _httpMethodFactory('delete'),
+            identifier: function identifier(newIdentifier) {
+                if (newIdentifier === undefined) {
+                    return scope.get('config').get('entityIdentifier');
+                }
+
+                scope.assign('config', 'entityIdentifier', newIdentifier);
+
+                return endpoint;
+            },
+            get: _httpMethodFactory('get', false),
+            head: _httpMethodFactory('head', false),
+            header: function header(key, value) {
+                return scope.assign('headers', key, value);
+            },
+            headers: function headers() {
+                return scope.get('headers');
+            },
+            'new': function _new(url) {
+                var childScope = scope['new']();
+                childScope.set('url', url);
+
+                return endpointFactory(childScope);
+            },
+            on: scope.on,
+            once: scope.once,
+            patch: _httpMethodFactory('patch'),
+            post: _httpMethodFactory('post'),
+            put: _httpMethodFactory('put'),
+            url: function url() {
+                return scope.get('url');
+            }
+        });
+
+        return endpoint;
+    };
+};
+
+module.exports = exports['default'];

dist/es5/model/entity.js

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+exports["default"] = function (_data, endpoint) {
+    return {
+        all: endpoint.all,
+        custom: endpoint.custom,
+        data: function data() {
+            return _data;
+        },
+        "delete": endpoint["delete"],
+        id: function id() {
+            return _data[endpoint.identifier()];
+        },
+        one: endpoint.one,
+        save: function save() {
+            for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
+                args[_key] = arguments[_key];
+            }
+
+            return endpoint.put.apply(endpoint, [_data].concat(args));
+        },
+        url: endpoint.url
+    };
+};
+
+module.exports = exports["default"];