proxy implementation, tests

Author: epoberezkin

.eslintrc.yml

@@ -0,0 +1,32 @@
+env:
+  node: true
+extends: 'eslint:recommended'
+globals:
+  Promise: false
+parserOptions:
+  ecmaVersion: 6
+rules:
+  indent: [ 2, 2, { SwitchCase: 1 } ]
+  no-trailing-spaces: 2
+  quotes: [ 2, single, avoid-escape ]
+  linebreak-style: [ 2, unix ]
+  semi: [ 2, always ]
+  valid-jsdoc: [ 2, { requireReturn: false } ]
+  no-invalid-this: 2
+  no-unused-vars: [ 2, { args: none } ]
+#  no-console: [ 2, { allow: [ warn, error ] } ]
+  no-console: 0
+  block-scoped-var: 2
+  complexity: [ 2, 8 ]
+  curly: [ 2, multi-or-nest, consistent ]
+  dot-location: [ 2, property ]
+  dot-notation: 2
+  no-else-return: 2
+  no-eq-null: 2
+  no-fallthrough: 2
+  no-return-assign: 2
+  strict: [ 2, global ]
+  no-shadow: 1
+  no-use-before-define: [ 2, nofunc ]
+  callback-return: 2
+  no-path-concat: 2

README.md

@@ -1,2 +1,97 @@
 # jsonscript-proxy
-Proxy server for scripted processing of other services
+
+Proxy server for batch processing of other services using [JSONScript](https://github.com/JSONScript/jsonscript).
+
+
+## Install
+
+To run proxy server using configuration file (not implemented yet):
+
+```
+npm install -g jsonscript-proxy
+```
+
+To add proxy to the existing express app
+
+```
+npm install jsonscript-proxy
+```
+
+
+## Getting started
+
+Sample proxy:
+
+```JavaScript
+var express = require('express');
+var app = express();
+var bodyParser = require('body-parser');
+var jsonscriptProxy = require('jsonscript-proxy');
+
+// app needs body parser for JSON even if no endpoint uses it.
+// it is needed for JSONScript middleware
+app.use(bodyParser.json());
+
+/**
+ * The code below adds JSONScript proxy on the endpoint '/js'
+ * that allows processing any scripts combining existing services
+ */
+app.post('/js', jsonscriptProxy({
+  services: {
+    service1: { basePath: 'http://localhost:3001' },
+    service2: { basePath: 'http://localhost:3002' },
+  }
+}));
+
+app.listen(3000);
+```
+
+Now you can send POST requests to `/js` endpoint with the body containing the script and an optional data instance that will be processed by JSONScript interpreter. For example, with this request:
+
+```json
+{
+  "script": {
+    "res1": { "$$service1.get": { "path": "/resource/1" } },
+    "res2": { "$$service2.get": { "path": "/resource/2" } }
+  }
+}
+```
+
+the response will be a combination of two responses (both requests are processed in parallel):
+
+```javascript
+{
+  "res1": {
+    "statusCode": 200,
+    "headers": { /* response headers for the 1st request */ },
+    "request": { "method": "get", "path": "/resource/1" },
+    "body": { /* response body 1 */ }
+  },
+  "res2": {
+    "statusCode": 200,
+    "headers": { /* response headers for the 2nd request */ },
+    "request": { "method": "get", "path": "/resource/2" },
+    "body": { /* response body 2 */ }
+  }
+}
+```
+
+If option `processResponse: "body"` were used the result would have been:
+
+```javascript
+{
+  "res1": { /* response body 1 */ },
+  "res2": { /* response body 2 */ }
+}
+```
+
+Options passed to proxy middleware should be valid according to the [options schema](https://github.com/JSONScript/jsonscript-proxy/blob/master/config_schema.json).
+
+JSONScript also supports sequential evaluation, conditionals, data manipulation, functions etc. So you can implement an advanced logic in your script and it will be executed in the server without sending responses of individual requests to the client.
+
+See [JSONScript Language](https://github.com/JSONScript/jsonscript/blob/master/LANGUAGE.md) for more information.
+
+
+## License
+
+[MIT](https://github.com/JSONScript/jsonscript-proxy/blob/master/LICENSE)

config_schema.json

@@ -0,0 +1,53 @@
+{
+  "id": "https://raw.githubusercontent.com/JSONScript/jsonscript-proxy/master/config_schema.json",
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "Configuration",
+  "description": "Schema for proxy server configuration file (and for config passed to proxy middleware)",
+  "type": "object",
+  "required": ["services"],
+  "properties": {
+    "services": {
+      "title": "proxied services",
+      "description": "each property name will be an executor exposed to JSONScript interpreter",
+      "type": "object",
+      "minProperties": 1,
+      "additionalProperties": false,
+      "patternProperties": {
+        "^[A-Za-z_$][A-Za-z_$0-9]+$": { "$ref": "#/definitions/service" }
+      }
+    },
+    "jsonscript": {
+      "description": "options passed to JSONScript interpreter",
+      "type": "object"
+    },
+    "processResponse": { "$ref": "#/definitions/processResponse" }
+  },
+  "definitions": {
+    "service": {
+      "description": "proxied service definition",
+      "required": ["basePath"],
+      "properties": {
+        "basePath": {
+          "type": "string",
+          "format": "uri"
+        },
+        "processResponse": { "$ref": "#/definitions/processResponse" }
+      }
+    },
+    "processResponse": {
+      "description": "defines how response from service is processed",
+      "anyOf": [
+        {
+          "description": "return only response body if status code is < 300, throw an exception otherwise",
+          "type": "string",
+          "enum": ["body"]
+        },
+        {
+          "description": "uses custom keyword 'typeof', function should return result or throw exception",
+          "not": { "type": ["string", "number", "array", "object", "boolean", "null"] },
+          "typeof": "function"
+        }
+      ]
+    }
+  }
+}

index.js

@@ -0,0 +1,125 @@
+'use strict';
+
+var JSONScript = require('jsonscript-js')
+  , request = require('request')
+  , Ajv = require('ajv')
+  , defineKeywords = require('ajv-keywords')
+  , _ = require('lodash')
+  , optionsSchema = require('./config_schema.json')
+  , validateOptions = getValidator();
+
+module.exports = jsonscriptProxy;
+
+
+var METHODS = ['get', 'post', 'put', 'delete'];
+function jsonscriptProxy(options) {
+  if (!validateOptions(options)) {
+    console.log('Invalid options:\n', validateOptions.errors);
+    throw new Error('Invalid options');
+  }
+
+  var js = JSONScript(options.jsonscript || { strict: true });
+  for (var key in options.services)
+    js.addExecutor(key, getExecutor(options.services[key]));
+  evaluator.js = js;
+
+  return evaluator;
+
+
+  function evaluator(req, res) {
+    var script = req.body.script;
+    var data = req.body.data;
+    var valid = js.validate(script);
+    if (valid) {
+      js.evaluate(script, data)
+      .then(function (value) {
+        res.json(value);
+      }, function (err) {
+        res.status(err.errors ? 400 : err.statusCode || 500)
+        .send({
+          error: err.message,
+          errors: err.errors
+        });
+      });
+    } else {
+      res.status(400)
+      .send({
+        error: 'script is invalid',
+        errors: js.validate.errors
+      });
+    }
+  }
+
+
+  function getExecutor(service) {
+    var processResponse = processResponseFunc(service.processResponse || options.processResponse);
+    addExecutorMethods();
+    return execRouter;
+
+    function execRouter(args) {
+      var opts = {
+        uri: service.basePath + args.path,
+        headers: args.headers,
+        json: args.body || true
+      };
+
+      return new (options.Promise || Promise)(function (resolve, reject) {
+        request[args.method](opts, function (err, resp) {
+          if (err) return reject(err);
+          resolve(processResponse(resp, args));
+        });
+      });
+    }
+
+    function addExecutorMethods() {
+      METHODS.forEach(function (method) {
+        execRouter[method] = function(args) {
+          if (args.method && args.method != method) {
+            console.warn('method specified in args (' + args.method +
+                          ') is different from $method in instruction (' + method + '), used ' + method);
+          }
+          args.method = method;
+          return execRouter(args);
+        };
+      });
+    }
+  }
+}
+
+
+function getValidator() {
+  var ajv = Ajv({ allErrors: true });
+  defineKeywords(ajv, 'typeof');
+  return ajv.compile(optionsSchema);
+}
+
+
+function processResponseFunc(processResponse) {
+  return processResponse == 'body'
+          ? bodyProcessResponse
+          : typeof processResponse == 'function'
+            ? processResponse
+            : defaultProcessResponse;
+}
+
+
+function bodyProcessResponse(resp) {
+  if (resp.statusCode < 300) return resp.body;
+  throw new HttpError(resp);
+}
+
+
+function defaultProcessResponse(resp, args) {
+  resp = _.pick(resp, 'statusCode', 'headers', 'body');
+  resp.request = args;
+  return resp;
+}
+
+
+function HttpError(resp) {
+  this.message = resp.body ? JSON.stringify(resp.body) : 'Error';
+  this.statusCode = resp.statusCode;
+}
+
+HttpError.prototype = Object.create(Error.prototype);
+HttpError.prototype.constructor = HttpError;

package.json

@@ -0,0 +1,42 @@
+{
+  "name": "jsonscript-proxy",
+  "version": "0.1.0",
+  "description": "Proxy server for scripted processing of other services using JSONScript",
+  "main": "index.js",
+  "scripts": {
+    "test": "npm run eslint && npm run test-cov",
+    "test-spec": "mocha spec/*.spec.js -R spec",
+    "test-cov": "istanbul cover -x 'spec/**' node_modules/mocha/bin/_mocha -- spec/*.spec.js -R spec",
+    "eslint": "eslint index.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/JSONScript/jsonscript-proxy.git"
+  },
+  "keywords": [
+    "JSONScript",
+    "proxy server",
+    "batch processing"
+  ],
+  "author": "Evgeny Poberezkin",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/JSONScript/jsonscript-proxy/issues"
+  },
+  "homepage": "https://github.com/JSONScript/jsonscript-proxy#readme",
+  "dependencies": {
+    "ajv": "^4.1.2",
+    "ajv-keywords": "^0.2.0",
+    "jsonscript-js": "^0.4.2",
+    "lodash": "^4.13.1",
+    "request": "^2.72.0"
+  },
+  "devDependencies": {
+    "body-parser": "^1.15.1",
+    "eslint": "^2.12.0",
+    "express": "^4.13.4",
+    "istanbul": "^0.4.3",
+    "mocha": "^2.5.3",
+    "supertest": "^1.2.0"
+  }
+}

spec/proxy.js

@@ -0,0 +1,14 @@
+'use strict';
+
+var express = require('express');
+var bodyParser = require('body-parser');
+var jsonscriptProxy = require('..');
+var _ = require('lodash');
+
+
+module.exports = function createProxy(options) {
+  var app = express();
+  app.use(bodyParser.json());
+  app.post('/js', jsonscriptProxy(options));
+  return app;
+};