3 |

4 | 5 |

6 | 9 |

10 | 11 |

12 |

13 |     
50 |   </div>
51 | </query-editor-row>
52 |

--------------------------------------------------------------------------------
/src/partials/query.editor.html:
--------------------------------------------------------------------------------
 1 | <query-editor-row query-ctrl="ctrl" class="generic-datasource-query-row grafana-simple-sql-datasource" has-text-edit-mode="true">
 2 |   <div class="gf-form-inline">
 3 |     <div class="gf-form">
 4 |       <select class="gf-form-input" ng-model="ctrl.target.type" ng-options="f as f for f in ['table', 'timeseries']"></select>      
 5 |     </div>
 6 |     
 9 |     <div class="gf-form">
10 |       <select class="gf-form-input" ng-model="ctrl.target.utc" ng-options="f as f for f in ['utc', 'localtime']"></select>      
11 |     </div>
12 |     <textarea class="gf-form-input" ng-model="ctrl.target.target" spellcheck="false" ng-blur="ctrl.onChangeInternal()" />
13 |     
50 |   </div>
51 | </query-editor-row>
52 |

--------------------------------------------------------------------------------
/src/datasource.js:
--------------------------------------------------------------------------------
  1 | import _ from "lodash";
  2 | 
  3 | export class GenericDatasource {
  4 | 
  5 |   constructor(instanceSettings, $q, backendSrv, templateSrv) {
  6 |     this.type = instanceSettings.type;
  7 |     this.url = instanceSettings.url || "";
  8 |     var m = /con\=(.*)/.exec(this.url.split("?")[1]);
  9 |     this.connection = m ? m[1]: null;
 10 |     this.name = instanceSettings.name;
 11 |     this.q = $q;
 12 |     this.backendSrv = backendSrv;
 13 |     this.templateSrv = templateSrv;
 14 |   }
 15 | 
 16 |   buildRequest(rqtype, data){
 17 |     return { 
 18 |       type: rqtype,
 19 |       body: data,
 20 |       url: this.connection 
 21 |     };
 22 |   }
 23 | 
 24 |   query(options) {
 25 |     var query = this.buildQueryParameters(options);
 26 |     
 27 |     if (query.targets.length <= 0) {
 28 |       return this.q.when({data: []});
 29 |     }
 30 | 
 31 |     return this.backendSrv.datasourceRequest({
 32 |       url: this.url,
 33 |       data: this.buildRequest("query", query ),
 34 |       method: 'POST',
 35 |       headers: { 'Content-Type': 'application/json' }
 36 |     });
 37 |   }
 38 | 
 39 |   testDatasource() {
 40 |     return this.backendSrv.datasourceRequest({
 41 |       url: this.url,
 42 |       method: 'POST',
 43 |       data: this.buildRequest("test", null)
 44 |     }).then(result => {
 45 |       return { status: "success", message: "Data source is working", title: "Success" };
 46 |     }).catch(result => {
 47 |       return { status: "error", message: result, title: "Error" };
 48 |     });
 49 |   }
 50 | 
 51 |   annotationQuery(options) {
 52 |     var annotationQuery = _.assignIn({}, options);
 53 |     annotationQuery.annotation.query = this.templateSrv.replace(options.annotation.query, {}, 'glob'); 
 54 |     
 55 |     return this.backendSrv.datasourceRequest({
 56 |       url: this.url,
 57 |       method: 'POST',
 58 |       data: this.buildRequest("annotations", annotationQuery)
 59 |     }).then(result => {
 60 |       return result.data;
 61 |     });
 62 |   }
 63 | 
 64 |   metricFindQuery(options) {
 65 |     var opsAsString = typeof (options) === "string";
 66 |     if(options && options.type == 'sql')
 67 |       // TODO: Parser?
 68 |       return this.q.when([]);
 69 |     var target = opsAsString ? options : options.target;
 70 |     var interpolated = {
 71 |         target: this.templateSrv.replace(target, null, 'regex')
 72 |     };
 73 | 
 74 |     return this.backendSrv.datasourceRequest({
 75 |       url: this.url,
 76 |       data: this.buildRequest("search", interpolated ),
 77 |       method: 'POST',
 78 |       headers: { 'Content-Type': 'application/json' }
 79 |     }).then(this.mapToTextValue);
 80 |   }
 81 | 
 82 |   mapToTextValue(result) {
 83 |     return _.map(result.data, (d, i) => {
 84 |       if (d && d.text && d.value) {
 85 |         return { text: d.text, value: d.value };
 86 |       } else if (_.isObject(d)) {
 87 |         return { text: d, value: i};
 88 |       }
 89 |       return { text: d, value: d };
 90 |     });
 91 |   }
 92 | 
 93 |   buildQueryParameters(options) {
 94 |     var clonedOptions = _.cloneDeep(options);
 95 |     var targets = _.filter(clonedOptions.targets, target => 
 96 |       target.target !== 'select metric' && !target.hide);
 97 | 
 98 |     targets = _.map(targets, target => 
 99 |       _.assignIn(target, { target: this.templateSrv.replace(target.target, options.scopedVars, "distributed")}));
100 | 
101 |     clonedOptions.targets = targets;
102 | 
103 |     return clonedOptions;
104 |   }
105 | }
106 |

--------------------------------------------------------------------------------
/spec/sqlproxyserver_spec.js:
--------------------------------------------------------------------------------
 1 | // Loading dist version instead "test" because I have no idea about
 2 | // how to prevent the test side to be "babelized"
 3 | var SQLProxyServer = require("../../serverside/sqlproxyserver.js");
 4 | import Q from "q";
 5 | import _ from "lodash";
 6 | 
 7 | describe('sqlproxyserver', function() {
 8 |     function mocksqldriver(options){
 9 |         this.options = options;
10 |     }
11 |     mocksqldriver.prototype.connect = function(){
12 |         if(!this.options.url)
13 |             return Q.reject("Invalid or empty connection string");
14 |         return Q.resolve(this.options);
15 |     };
16 |     mocksqldriver.prototype.query = function(cmd){
17 |         var results = {
18 |             query:cmd,
19 |             columns:{
20 |                 metric:{type:{name:'VarChar'}},
21 |                 value:{type:{name:'Int'}},
22 |                 timestamp:{type:{name:'DateTime'}}
23 |             },
24 |             rows:[{metric:'metric', value:1, timestamp:new Date()}]
25 |         };
26 |         return this.connect()
27 |                 .then(() => results);
28 |     };
29 |     
30 |     var sqlproxyds = null;
31 |     var query = {type:'query',url:'mssql://....',
32 |                 body: {
33 |                     targets:[{
34 |                         target: 'SELECT 1',
35 |                         type: 'timeseries' 
36 |                     },{
37 |                         target: 'SELECT 1',
38 |                         type: 'table' 
39 |                     }],
40 |                     range:{from: '',to: ''}}
41 |                 };
42 |     
43 |     
44 |     beforeEach(function() {
45 |         sqlproxyds = new SQLProxyServer(()=>Q.resolve(mocksqldriver));
46 |     });
47 | 
48 |     it('should fail for empty connection string', function(done) {
49 |         sqlproxyds.execCommand({type:'test'})
50 |             .catch(err => done());
51 |     });
52 | 
53 |     it('should test', function(done) {
54 |         sqlproxyds.execCommand({type:'test', url:'mssql://....', body:{targets:[{}]}})
55 |             .then(r => {
56 |                assert(r.status == 'sucess', "Test failed");
57 |                done();
58 |             })
59 |             .catch(done);
60 |     });
61 | 
62 |     it('query shuld return timeseries', function(done) {
63 |         sqlproxyds.execCommand(query)
64 |             .then(r => {
65 |                 assert(r, "No data returned");
66 |                 assert(r.length == query.body.targets.length, 
67 |                     "Wrong number of data set returned. Expected " + query.body.targets.length + " got " + r.length);
68 |                 var tsdt = r[0].datapoints;
69 |                 assert(tsdt[0][0] == 1, "Invalid data value returned");
70 |                 assert(new Date(tsdt[0][1]).getFullYear() == (new Date()).getFullYear(), 
71 |                     "Invalid timestamp returned " + new Date(tsdt[0][1]));
72 |                 done();
73 |             })
74 |             .catch(done);
75 |     });
76 |     it('query shuld return table', function(done) {
77 |         sqlproxyds.execCommand(query)
78 |             .then(r => {
79 |                 assert(r, "No data returned");
80 |                 assert(r.length == query.body.targets.length, 
81 |                     "Wrong number of data set returned. Expected " + query.body.targets.length + " got " + r.length);
82 |                 var tsdt = r[1];
83 |                 assert(tsdt.columns, "No columns found");
84 |                 assert(tsdt.rows, "No rows found");
85 |                 assert(tsdt.type == "table", "Inavlid type, espected 'table' found " + tsdt.type);
86 |                 assert(tsdt.columns.length != 0, "Invalid number of columns");
87 |                 assert(tsdt.columns.filter(c => ["number","string","time"].indexOf(c.type) == -1).length == 0, "Found invalid column type");
88 |                 assert(tsdt.columns.length == tsdt.rows[0].length, "Number fields don't not match number of columns");
89 |                 done();
90 |             })
91 |             .catch(done);
92 |     });
93 | });
94 |

--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | [![repofunding](https://img.shields.io/badge/powered%20by-repofunding-green.svg)](https://github.com/gbrian/repofunding) [![](https://img.shields.io/badge/support-5€-lightgray.svg)](https://www.paypal.me/repofunding/5)
  2 | # grafana-simple-sql-datasource
  3 | 
  4 | Allows querying SQL based datasources like SQL Server.
  5 | 
  6 | ![SQL Plugi](https://raw.githubusercontent.com/gbrian/grafana-simple-sql-datasource/master/overview.png "Query editor")
  7 | 
  8 | 
  9 | ## Usage
 10 | Currently the plugin requires a proxy server running to communicate with the database.
 11 | 
 12 | **Install sqlproxyserver**
 13 |  
 14 |  * Run `npm install` at the `dist/serverside` folder to install all dependencies
 15 |  * Run npm install on the plugin directory
 16 |  * Run server side code `dist/serverside/sqlproxyserver.js`
 17 |  * Test on your browser `http://myserver:port/con=mssql://user:name@server/database` you must get a `{"status":"sucess"}` response
 18 | 
 19 | **Add new datasource**
 20 | Add a new datasource to Grafana and set the url to:
 21 | 
 22 | ````
 23 | http://myserver:port/con=mssql://user:name@server/database
 24 | ````
 25 | 
 26 | Where:
 27 | 
 28 |  * **myserver:port** : Is the server where `sqlproxyserver` is running
 29 |  * **con**: Specifies the sql connection string
 30 | 
 31 | ## SQL Databases
 32 | Currently supported SQL databases
 33 | 
 34 | ### SQL Server
 35 | SQL Server connection is managed by the mssqp package https://www.npmjs.com/package/mssql  
 36 |   
 37 | ## Features
 38 | Following features has been implemented
 39 | 
 40 | ![Query editor](https://raw.githubusercontent.com/gbrian/grafana-simple-sql-datasource/master/query_editor.png "Query editor")
 41 | 
 42 | ### Metrics
 43 | It is possible to define two different types: `timeseries` and `table`
 44 | 
 45 | ### Annotation
 46 | Annotation querires must return the following fields:
 47 |  
 48 |  * **title**: Annotation header
 49 |  * **text**:  Annotation description
 50 |  * **tags**: Annotation tags
 51 |  * **time**: Annotation time
 52 | 
 53 | ## Notes
 54 | ### Time
 55 | UTC and Localtime. Currently you must specify if time returned by the query is UTC or local. 
 56 | The plugin will convert localtime to UTC in order to be correctly renderer.
 57 | ### Template
 58 | You can use `$from` and `$to` to refer to selected time period in your queries like:
 59 | 
 60 | ````
 61 | select 'Metric Name' as metric, -- Use a literal or group by a column for the labels
 62 | 		count(*) as hits, -- Just counting occurrences
 63 | 		ts as [timestamp]
 64 | from (
 65 | 	Select dbo.scale_interval(dateColumn, '$Interval') as ts -- scale datetime to $Interval (e.g. 10m)
 66 | 	from myTable
 67 | 	where dateColumn >= '$from' and dateColumn < '$to'
 68 | ) T
 69 | group by ts
 70 | order by ts asc
 71 | ```` 
 72 | 
 73 | ### MISC
 74 | #### scale_interval
 75 | Simple TSQL to group series by an interval
 76 | 
 77 | ````
 78 | ALTER FUNCTION scale_interval 
 79 | (
 80 | 	-- Add the parameters for the function here
 81 | 	@dt as datetime, @interval as varchar(100)
 82 | )
 83 | RETURNS DateTime
 84 | AS
 85 | BEGIN
 86 | 	DECLARE @amount int = 10
 87 | 
 88 | 	IF  CHARINDEX('m', @interval) <> 0
 89 | 	BEGIN
 90 | 		SET @amount = CAST(REPLACE(@interval, 'm', '') as int)
 91 | 		return dateadd(minute, datediff(mi, 0, @dt) / @amount * @amount, 0)
 92 | 	END
 93 | 	IF CHARINDEX('h', @interval) <> 0
 94 | 	BEGIN
 95 | 		SET @amount = CAST(REPLACE(@interval, 'h', '') as int)
 96 | 		return dateadd(hour, datediff(hour, 0, @dt) / @amount * @amount, 0)
 97 | 	END
 98 | 	IF CHARINDEX('d', @interval) <> 0
 99 | 	BEGIN
100 | 		SET @amount = CAST(REPLACE(@interval, 'd', '') as int)
101 | 		return dateadd(day, datediff(day, 0, @dt) / @amount * @amount, 0) 
102 | 	END
103 | 	RETURN NULL
104 | END
105 | GO
106 | ````
107 | 
108 | 
109 | ## Thanks to
110 | Grafana team and [@bergquist](https://github.com/bergquist)
111 |  
112 | ## *Powered by <a href="https://github.com/gbrian/repofunding">@repofunding*<img src="https://avatars1.githubusercontent.com/u/38230168?s=460&v=4" width="32" height="32"/></a>
113 |

--------------------------------------------------------------------------------
/dist/query_ctrl.js:
--------------------------------------------------------------------------------
  1 | 'use strict';
  2 | 
  3 | System.register(['app/plugins/sdk', './css/query-editor.css!'], function (_export, _context) {
  4 |   "use strict";
  5 | 
  6 |   var QueryCtrl, _createClass, GenericDatasourceQueryCtrl;
  7 | 
  8 |   function _classCallCheck(instance, Constructor) {
  9 |     if (!(instance instanceof Constructor)) {
 10 |       throw new TypeError("Cannot call a class as a function");
 11 |     }
 12 |   }
 13 | 
 14 |   function _possibleConstructorReturn(self, call) {
 15 |     if (!self) {
 16 |       throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
 17 |     }
 18 | 
 19 |     return call && (typeof call === "object" || typeof call === "function") ? call : self;
 20 |   }
 21 | 
 22 |   function _inherits(subClass, superClass) {
 23 |     if (typeof superClass !== "function" && superClass !== null) {
 24 |       throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
 25 |     }
 26 | 
 27 |     subClass.prototype = Object.create(superClass && superClass.prototype, {
 28 |       constructor: {
 29 |         value: subClass,
 30 |         enumerable: false,
 31 |         writable: true,
 32 |         configurable: true
 33 |       }
 34 |     });
 35 |     if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
 36 |   }
 37 | 
 38 |   return {
 39 |     setters: [function (_appPluginsSdk) {
 40 |       QueryCtrl = _appPluginsSdk.QueryCtrl;
 41 |     }, function (_cssQueryEditorCss) {}],
 42 |     execute: function () {
 43 |       _createClass = function () {
 44 |         function defineProperties(target, props) {
 45 |           for (var i = 0; i < props.length; i++) {
 46 |             var descriptor = props[i];
 47 |             descriptor.enumerable = descriptor.enumerable || false;
 48 |             descriptor.configurable = true;
 49 |             if ("value" in descriptor) descriptor.writable = true;
 50 |             Object.defineProperty(target, descriptor.key, descriptor);
 51 |           }
 52 |         }
 53 | 
 54 |         return function (Constructor, protoProps, staticProps) {
 55 |           if (protoProps) defineProperties(Constructor.prototype, protoProps);
 56 |           if (staticProps) defineProperties(Constructor, staticProps);
 57 |           return Constructor;
 58 |         };
 59 |       }();
 60 | 
 61 |       _export('GenericDatasourceQueryCtrl', GenericDatasourceQueryCtrl = function (_QueryCtrl) {
 62 |         _inherits(GenericDatasourceQueryCtrl, _QueryCtrl);
 63 | 
 64 |         function GenericDatasourceQueryCtrl($scope, $injector, uiSegmentSrv) {
 65 |           _classCallCheck(this, GenericDatasourceQueryCtrl);
 66 | 
 67 |           var _this = _possibleConstructorReturn(this, (GenericDatasourceQueryCtrl.__proto__ || Object.getPrototypeOf(GenericDatasourceQueryCtrl)).call(this, $scope, $injector));
 68 | 
 69 |           _this.scope = $scope;
 70 |           _this.uiSegmentSrv = uiSegmentSrv;
 71 |           _this.target.target = _this.target.target || 'select metric';
 72 |           _this.target.type = _this.target.type || 'timeserie';
 73 |           _this.target.cmdtype = _this.target.cmdtype || 'sql';
 74 |           _this.target.utc = _this.target.utc || 'localtime';
 75 |           return _this;
 76 |         }
 77 | 
 78 |         _createClass(GenericDatasourceQueryCtrl, [{
 79 |           key: 'getOptions',
 80 |           value: function getOptions() {
 81 |             return this.datasource.metricFindQuery(this.target).then(this.uiSegmentSrv.transformToSegments(false));
 82 |             // Options have to be transformed by uiSegmentSrv to be usable by metric-segment-model directive
 83 |           }
 84 |         }, {
 85 |           key: 'toggleEditorMode',
 86 |           value: function toggleEditorMode() {
 87 |             this.target.rawQuery = !this.target.rawQuery;
 88 |           }
 89 |         }, {
 90 |           key: 'onChangeInternal',
 91 |           value: function onChangeInternal() {
 92 |             this.panelCtrl.refresh(); // Asks the panel to refresh data.
 93 |           }
 94 |         }]);
 95 | 
 96 |         return GenericDatasourceQueryCtrl;
 97 |       }(QueryCtrl));
 98 | 
 99 |       _export('GenericDatasourceQueryCtrl', GenericDatasourceQueryCtrl);
100 | 
101 |       GenericDatasourceQueryCtrl.templateUrl = 'partials/query.editor.html';
102 |     }
103 |   };
104 | });
105 | //# sourceMappingURL=query_ctrl.js.map
106 |

--------------------------------------------------------------------------------
/dist/datasource.js:
--------------------------------------------------------------------------------
  1 | "use strict";
  2 | 
  3 | System.register(["lodash"], function (_export, _context) {
  4 |   "use strict";
  5 | 
  6 |   var _, _createClass, GenericDatasource;
  7 | 
  8 |   function _classCallCheck(instance, Constructor) {
  9 |     if (!(instance instanceof Constructor)) {
 10 |       throw new TypeError("Cannot call a class as a function");
 11 |     }
 12 |   }
 13 | 
 14 |   return {
 15 |     setters: [function (_lodash) {
 16 |       _ = _lodash.default;
 17 |     }],
 18 |     execute: function () {
 19 |       _createClass = function () {
 20 |         function defineProperties(target, props) {
 21 |           for (var i = 0; i < props.length; i++) {
 22 |             var descriptor = props[i];
 23 |             descriptor.enumerable = descriptor.enumerable || false;
 24 |             descriptor.configurable = true;
 25 |             if ("value" in descriptor) descriptor.writable = true;
 26 |             Object.defineProperty(target, descriptor.key, descriptor);
 27 |           }
 28 |         }
 29 | 
 30 |         return function (Constructor, protoProps, staticProps) {
 31 |           if (protoProps) defineProperties(Constructor.prototype, protoProps);
 32 |           if (staticProps) defineProperties(Constructor, staticProps);
 33 |           return Constructor;
 34 |         };
 35 |       }();
 36 | 
 37 |       _export("GenericDatasource", GenericDatasource = function () {
 38 |         function GenericDatasource(instanceSettings, $q, backendSrv, templateSrv) {
 39 |           _classCallCheck(this, GenericDatasource);
 40 | 
 41 |           this.type = instanceSettings.type;
 42 |           this.url = instanceSettings.url || "";
 43 |           var m = /con\=(.*)/.exec(this.url.split("?")[1]);
 44 |           this.connection = m ? m[1] : null;
 45 |           this.name = instanceSettings.name;
 46 |           this.q = $q;
 47 |           this.backendSrv = backendSrv;
 48 |           this.templateSrv = templateSrv;
 49 |         }
 50 | 
 51 |         _createClass(GenericDatasource, [{
 52 |           key: "buildRequest",
 53 |           value: function buildRequest(rqtype, data) {
 54 |             return {
 55 |               type: rqtype,
 56 |               body: data,
 57 |               url: this.connection
 58 |             };
 59 |           }
 60 |         }, {
 61 |           key: "query",
 62 |           value: function query(options) {
 63 |             var query = this.buildQueryParameters(options);
 64 | 
 65 |             if (query.targets.length <= 0) {
 66 |               return this.q.when({ data: [] });
 67 |             }
 68 | 
 69 |             return this.backendSrv.datasourceRequest({
 70 |               url: this.url,
 71 |               data: this.buildRequest("query", query),
 72 |               method: 'POST',
 73 |               headers: { 'Content-Type': 'application/json' }
 74 |             });
 75 |           }
 76 |         }, {
 77 |           key: "testDatasource",
 78 |           value: function testDatasource() {
 79 |             return this.backendSrv.datasourceRequest({
 80 |               url: this.url,
 81 |               method: 'POST',
 82 |               data: this.buildRequest("test", null)
 83 |             }).then(function (result) {
 84 |               return { status: "success", message: "Data source is working", title: "Success" };
 85 |             }).catch(function (result) {
 86 |               return { status: "error", message: result, title: "Error" };
 87 |             });
 88 |           }
 89 |         }, {
 90 |           key: "annotationQuery",
 91 |           value: function annotationQuery(options) {
 92 |             var annotationQuery = _.assignIn({}, options);
 93 |             annotationQuery.annotation.query = this.templateSrv.replace(options.annotation.query, {}, 'glob');
 94 | 
 95 |             return this.backendSrv.datasourceRequest({
 96 |               url: this.url,
 97 |               method: 'POST',
 98 |               data: this.buildRequest("annotations", annotationQuery)
 99 |             }).then(function (result) {
100 |               return result.data;
101 |             });
102 |           }
103 |         }, {
104 |           key: "metricFindQuery",
105 |           value: function metricFindQuery(options) {
106 |             var opsAsString = typeof options === "string";
107 |             if (options && options.type == 'sql')
108 |               // TODO: Parser?
109 |               return this.q.when([]);
110 |             var target = opsAsString ? options : options.target;
111 |             var interpolated = {
112 |               target: this.templateSrv.replace(target, null, 'regex')
113 |             };
114 | 
115 |             return this.backendSrv.datasourceRequest({
116 |               url: this.url,
117 |               data: this.buildRequest("search", interpolated),
118 |               method: 'POST',
119 |               headers: { 'Content-Type': 'application/json' }
120 |             }).then(this.mapToTextValue);
121 |           }
122 |         }, {
123 |           key: "mapToTextValue",
124 |           value: function mapToTextValue(result) {
125 |             return _.map(result.data, function (d, i) {
126 |               if (d && d.text && d.value) {
127 |                 return { text: d.text, value: d.value };
128 |               } else if (_.isObject(d)) {
129 |                 return { text: d, value: i };
130 |               }
131 |               return { text: d, value: d };
132 |             });
133 |           }
134 |         }, {
135 |           key: "buildQueryParameters",
136 |           value: function buildQueryParameters(options) {
137 |             var _this = this;
138 | 
139 |             var clonedOptions = _.cloneDeep(options);
140 |             var targets = _.filter(clonedOptions.targets, function (target) {
141 |               return target.target !== 'select metric' && !target.hide;
142 |             });
143 | 
144 |             targets = _.map(targets, function (target) {
145 |               return _.assignIn(target, { target: _this.templateSrv.replace(target.target, options.scopedVars, "distributed") });
146 |             });
147 | 
148 |             clonedOptions.targets = targets;
149 | 
150 |             return clonedOptions;
151 |           }
152 |         }]);
153 | 
154 |         return GenericDatasource;
155 |       }());
156 | 
157 |       _export("GenericDatasource", GenericDatasource);
158 |     }
159 |   };
160 | });
161 | //# sourceMappingURL=datasource.js.map
162 |

--------------------------------------------------------------------------------
/dist/datasource.js.map:
--------------------------------------------------------------------------------
1 | {"version":3,"sources":["../src/datasource.js"],"names":["_","GenericDatasource","instanceSettings","$q","backendSrv","templateSrv","type","url","m","exec","split","connection","name","q","rqtype","data","body","options","query","buildQueryParameters","targets","length","when","datasourceRequest","buildRequest","method","headers","then","status","message","title","catch","result","annotationQuery","assignIn","annotation","replace","opsAsString","target","interpolated","mapToTextValue","map","d","i","text","value","isObject","clonedOptions","cloneDeep","filter","hide","scopedVars"],"mappings":"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","file":"datasource.js","sourcesContent":["import _ from \"lodash\";\r\n\r\nexport class GenericDatasource {\r\n\r\n  constructor(instanceSettings, $q, backendSrv, templateSrv) {\r\n    this.type = instanceSettings.type;\r\n    this.url = instanceSettings.url || \"\";\r\n    var m = /con\\=(.*)/.exec(this.url.split(\"?\")[1]);\r\n    this.connection = m ? m[1]: null;\r\n    this.name = instanceSettings.name;\r\n    this.q = $q;\r\n    this.backendSrv = backendSrv;\r\n    this.templateSrv = templateSrv;\r\n  }\r\n\r\n  buildRequest(rqtype, data){\r\n    return { \r\n      type: rqtype,\r\n      body: data,\r\n      url: this.connection \r\n    };\r\n  }\r\n\r\n  query(options) {\r\n    var query = this.buildQueryParameters(options);\r\n    \r\n    if (query.targets.length <= 0) {\r\n      return this.q.when({data: []});\r\n    }\r\n\r\n    return this.backendSrv.datasourceRequest({\r\n      url: this.url,\r\n      data: this.buildRequest(\"query\", query ),\r\n      method: 'POST',\r\n      headers: { 'Content-Type': 'application/json' }\r\n    });\r\n  }\r\n\r\n  testDatasource() {\r\n    return this.backendSrv.datasourceRequest({\r\n      url: this.url,\r\n      method: 'POST',\r\n      data: this.buildRequest(\"test\", null)\r\n    }).then(result => {\r\n      return { status: \"success\", message: \"Data source is working\", title: \"Success\" };\r\n    }).catch(result => {\r\n      return { status: \"error\", message: result, title: \"Error\" };\r\n    });\r\n  }\r\n\r\n  annotationQuery(options) {\r\n    var annotationQuery = _.assignIn({}, options);\r\n    annotationQuery.annotation.query = this.templateSrv.replace(options.annotation.query, {}, 'glob'); \r\n    \r\n    return this.backendSrv.datasourceRequest({\r\n      url: this.url,\r\n      method: 'POST',\r\n      data: this.buildRequest(\"annotations\", annotationQuery)\r\n    }).then(result => {\r\n      return result.data;\r\n    });\r\n  }\r\n\r\n  metricFindQuery(options) {\r\n    var opsAsString = typeof (options) === \"string\";\r\n    if(options && options.type == 'sql')\r\n      // TODO: Parser?\r\n      return this.q.when([]);\r\n    var target = opsAsString ? options : options.target;\r\n    var interpolated = {\r\n        target: this.templateSrv.replace(target, null, 'regex')\r\n    };\r\n\r\n    return this.backendSrv.datasourceRequest({\r\n      url: this.url,\r\n      data: this.buildRequest(\"search\", interpolated ),\r\n      method: 'POST',\r\n      headers: { 'Content-Type': 'application/json' }\r\n    }).then(this.mapToTextValue);\r\n  }\r\n\r\n  mapToTextValue(result) {\r\n    return _.map(result.data, (d, i) => {\r\n      if (d && d.text && d.value) {\r\n        return { text: d.text, value: d.value };\r\n      } else if (_.isObject(d)) {\r\n        return { text: d, value: i};\r\n      }\r\n      return { text: d, value: d };\r\n    });\r\n  }\r\n\r\n  buildQueryParameters(options) {\r\n    var clonedOptions = _.cloneDeep(options);\r\n    var targets = _.filter(clonedOptions.targets, target => \r\n      target.target !== 'select metric' && !target.hide);\r\n\r\n    targets = _.map(targets, target => \r\n      _.assignIn(target, { target: this.templateSrv.replace(target.target, options.scopedVars, \"distributed\")}));\r\n\r\n    clonedOptions.targets = targets;\r\n\r\n    return clonedOptions;\r\n  }\r\n}\r\n"]}

--------------------------------------------------------------------------------
/spec/datasource_spec.js:
--------------------------------------------------------------------------------
  1 | import {Datasource} from "../module";
  2 | import Q from "q";
  3 | 
  4 | describe('GenericDatasource', function() {
  5 |     var ctx = {};
  6 | 
  7 |     beforeEach(function() {
  8 |         ctx.$q = Q;
  9 |         ctx.backendSrv = {};
 10 |         ctx.templateSrv = {};
 11 |         ctx.ds = new Datasource({}, ctx.$q, ctx.backendSrv, ctx.templateSrv);
 12 | 
 13 |     });
 14 | 
 15 |     it('should return an empty array when no targets are set', function(done) {
 16 |         ctx.ds.query({targets: []}).then(function(result) {
 17 |             expect(result.data).to.have.length(0);
 18 |             done();
 19 |         });
 20 |     });
 21 | 
 22 |     it('should return the server results when a target is set', function(done) {
 23 |         ctx.backendSrv.datasourceRequest = function(request) {
 24 |             request.data = request.data.body;
 25 |             return ctx.$q.when({
 26 |                 _request: request,
 27 |                 data: [
 28 |                     {
 29 |                         target: 'X',
 30 |                         datapoints: [1, 2, 3]
 31 |                     }
 32 |                 ]
 33 |             });
 34 |         };
 35 | 
 36 |         ctx.templateSrv.replace = function(data) {
 37 |           return data;
 38 |         }
 39 | 
 40 |         ctx.ds.query({targets: ['hits']}).then(function(result) {
 41 |             expect(result._request.data.targets).to.have.length(1);
 42 | 
 43 |             var series = result.data[0];
 44 |             expect(series.target).to.equal('X');
 45 |             expect(series.datapoints).to.have.length(3);
 46 |             done();
 47 |         });
 48 |     });
 49 | 
 50 |     it ('should return the metric results when a target is null', function(done) {
 51 |         ctx.backendSrv.datasourceRequest = function(request) {
 52 |             return ctx.$q.when({
 53 |                 _request: request,
 54 |                 data: [
 55 |                     "metric_0",
 56 |                     "metric_1",
 57 |                     "metric_2",
 58 |                 ]
 59 |             });
 60 |         };
 61 | 
 62 |         ctx.templateSrv.replace = function(data) {
 63 |             return data;
 64 |         }
 65 | 
 66 |         ctx.ds.metricFindQuery({target: null}).then(function(result) {
 67 |             expect(result).to.have.length(3);
 68 |             expect(result[0].text).to.equal('metric_0');
 69 |             expect(result[0].value).to.equal('metric_0');
 70 |             expect(result[1].text).to.equal('metric_1');
 71 |             expect(result[1].value).to.equal('metric_1');
 72 |             expect(result[2].text).to.equal('metric_2');
 73 |             expect(result[2].value).to.equal('metric_2');
 74 |             done();
 75 |         });
 76 |     });
 77 | 
 78 |     it ('should return the metric target results when a target is set', function(done) {
 79 |         ctx.backendSrv.datasourceRequest = function(request) {
 80 |             request.data = request.data.body;
 81 |             var target = request.data.target;
 82 |             var result = [target + "_0", target + "_1", target + "_2"];
 83 | 
 84 |             return ctx.$q.when({
 85 |                 _request: request,
 86 |                 data: result
 87 |             });
 88 |         };
 89 | 
 90 |         ctx.templateSrv.replace = function(data) {
 91 |             return data;
 92 |         }
 93 | 
 94 |         ctx.ds.metricFindQuery({target: 'search'}).then(function(result) {
 95 |             expect(result).to.have.length(3);
 96 |             expect(result[0].text).to.equal('search_0');
 97 |             expect(result[0].value).to.equal('search_0');
 98 |             expect(result[1].text).to.equal('search_1');
 99 |             expect(result[1].value).to.equal('search_1');
100 |             expect(result[2].text).to.equal('search_2');
101 |             expect(result[2].value).to.equal('search_2');
102 |             done();
103 |         });
104 |     });
105 | 
106 |     it ('should return the metric results when the target is an empty string', function(done) {
107 |         ctx.backendSrv.datasourceRequest = function(request) {
108 |             return ctx.$q.when({
109 |                 _request: request,
110 |                 data: [
111 |                     "metric_0",
112 |                     "metric_1",
113 |                     "metric_2",
114 |                 ]
115 |             });
116 |         };
117 | 
118 |         ctx.templateSrv.replace = function(data) {
119 |             return data;
120 |         }
121 | 
122 |         ctx.ds.metricFindQuery({target: ''}).then(function(result) {
123 |             expect(result).to.have.length(3);
124 |             expect(result[0].text).to.equal('metric_0');
125 |             expect(result[0].value).to.equal('metric_0');
126 |             expect(result[1].text).to.equal('metric_1');
127 |             expect(result[1].value).to.equal('metric_1');
128 |             expect(result[2].text).to.equal('metric_2');
129 |             expect(result[2].value).to.equal('metric_2');
130 |             done();
131 |         });
132 |     });
133 | 
134 |     it ('should return the metric results when the args are an empty object', function(done) {
135 |         ctx.backendSrv.datasourceRequest = function(request) {
136 |             return ctx.$q.when({
137 |                 _request: request,
138 |                 data: [
139 |                     "metric_0",
140 |                     "metric_1",
141 |                     "metric_2",
142 |                 ]
143 |             });
144 |         };
145 | 
146 |         ctx.templateSrv.replace = function(data) {
147 |             return data;
148 |         }
149 | 
150 |         ctx.ds.metricFindQuery({}).then(function(result) {
151 |             expect(result).to.have.length(3);
152 |             expect(result[0].text).to.equal('metric_0');
153 |             expect(result[0].value).to.equal('metric_0');
154 |             expect(result[1].text).to.equal('metric_1');
155 |             expect(result[1].value).to.equal('metric_1');
156 |             expect(result[2].text).to.equal('metric_2');
157 |             expect(result[2].value).to.equal('metric_2');
158 |             done();
159 |         });
160 |     });
161 | 
162 |     it ('should throw error when args are undefined', function(done) {
163 |         global.assert.throw(ctx.ds.metricFindQuery, Error, "Cannot read property 'target' of undefined");
164 |         done();
165 |     });
166 | 
167 |     it ('should throw error when args are null', function(done) {
168 |         global.assert.throw(function() { ctx.ds.metricFindQuery(null); }, Error, "Cannot read property 'target' of null");
169 |         done();
170 |     });
171 | 
172 |     it ('should return the metric target results when the args are a string', function(done) {
173 |         ctx.backendSrv.datasourceRequest = function(request) {
174 |             request.data = request.data.body;
175 |             var target = request.data.target;
176 |             var result = [target + "_0", target + "_1", target + "_2"];
177 | 
178 |             return ctx.$q.when({
179 |                 _request: request,
180 |                 data: result
181 |             });
182 |         };
183 | 
184 |         ctx.templateSrv.replace = function(data) {
185 |             return data;
186 |         }
187 | 
188 |         ctx.ds.metricFindQuery('search').then(function(result) {
189 |             expect(result).to.have.length(3);
190 |             expect(result[0].text).to.equal('search_0');
191 |             expect(result[0].value).to.equal('search_0');
192 |             expect(result[1].text).to.equal('search_1');
193 |             expect(result[1].value).to.equal('search_1');
194 |             expect(result[2].text).to.equal('search_2');
195 |             expect(result[2].value).to.equal('search_2');
196 |             done();
197 |         });
198 |     });
199 | 
200 |     it ('should return data as text and as value', function(done) {
201 |         var result = ctx.ds.mapToTextValue({data: ["zero", "one", "two"]});
202 | 
203 |         expect(result).to.have.length(3);
204 |         expect(result[0].text).to.equal('zero');
205 |         expect(result[0].value).to.equal('zero');
206 |         expect(result[1].text).to.equal('one');
207 |         expect(result[1].value).to.equal('one');
208 |         expect(result[2].text).to.equal('two');
209 |         expect(result[2].value).to.equal('two');
210 |         done();
211 |     });
212 | 
213 |     it ('should return text as text and value as value', function(done) {
214 |         var data = [
215 |             {text: "zero", value: "value_0"},
216 |             {text: "one", value: "value_1"},
217 |             {text: "two", value: "value_2"},
218 |         ];
219 | 
220 |         var result = ctx.ds.mapToTextValue({data: data});
221 | 
222 |         expect(result).to.have.length(3);
223 |         expect(result[0].text).to.equal('zero');
224 |         expect(result[0].value).to.equal('value_0');
225 |         expect(result[1].text).to.equal('one');
226 |         expect(result[1].value).to.equal('value_1');
227 |         expect(result[2].text).to.equal('two');
228 |         expect(result[2].value).to.equal('value_2');
229 |         done();
230 |     });
231 | 
232 |     it ('should return data as text and index as value', function(done) {
233 |         var data = [
234 |             {a: "zero", b: "value_0"},
235 |             {a: "one", b: "value_1"},
236 |             {a: "two", b: "value_2"},
237 |         ];
238 | 
239 |         var result = ctx.ds.mapToTextValue({data: data});
240 | 
241 |         expect(result).to.have.length(3);
242 |         expect(result[0].text).to.equal(data[0]);
243 |         expect(result[0].value).to.equal(0);
244 |         expect(result[1].text).to.equal(data[1]);
245 |         expect(result[1].value).to.equal(1);
246 |         expect(result[2].text).to.equal(data[2]);
247 |         expect(result[2].value).to.equal(2);
248 |         done();
249 |     });
250 | });
251 |

--------------------------------------------------------------------------------
/dist/serverside/sqlproxyserver.js:
--------------------------------------------------------------------------------
  1 | var _ = require("lodash");
  2 | var q = require("q");
  3 | var moment = require("moment");
  4 | 
  5 | function SQLProxyServer(providerFactory) {
  6 |     this.providerFactory = providerFactory || this.defaultProviderFactory;
  7 | }
  8 | 
  9 | SQLProxyServer.prototype.defaultProviderFactory = function(url){
 10 |     var m = /([^:]*).*/.exec(url);
 11 |     if(!m) return q.reject("Invalid connection " + url);
 12 |     try{
 13 |       return q.resolve(require('./' + m[1] + "driver.js"));
 14 |     }catch(e){
 15 |       return q.reject(e);
 16 |     }
 17 |   }
 18 | 
 19 | SQLProxyServer.prototype.loadProvider = function(req){
 20 |     return this.providerFactory(req.url)
 21 |         .then(provider => {
 22 |           req.provider = new provider(req);
 23 |           return req;
 24 |         });
 25 |   } 
 26 | 
 27 | SQLProxyServer.prototype.loadAPI = function(req){
 28 |     return this.loadProvider(req)
 29 |             .then(d => new this.API(req));
 30 |   }
 31 | 
 32 | SQLProxyServer.prototype.execCommand = function(req){
 33 |     return this.loadAPI(req)
 34 |             .then(api => api.execute());
 35 |   }
 36 | SQLProxyServer.prototype.getConnection = function(req){
 37 |     var consrc = [/con\=(.*)/.exec(req.url)[1], req.query.con, req.body.url];
 38 |     req.body.url = consrc.filter(s => s)[0];
 39 |   }
 40 | SQLProxyServer.prototype.runStandalone = function(){
 41 |     var express = require('express');
 42 |     var bodyParser = require('body-parser');
 43 |     var app = express();
 44 |     
 45 |     app.use((req, res, next)=>{
 46 |         res.setHeader('Access-Control-Allow-Origin', '*');
 47 |         res.setHeader('Access-Control-Allow-Headers', 'Origin, Accept, Accept-Version, Content-Length, Content-MD5, Content-Type, Date, X-Api-Version, X-Response-Time, X-PINGOTHER, X-CSRF-Token,Authorization');
 48 |         res.setHeader('Access-Control-Allow-Methods', '*');
 49 |         res.setHeader('Access-Control-Expose-Headers', 'X-Api-Version, X-Request-Id, X-Response-Time');
 50 |         res.setHeader('Access-Control-Max-Age', '1000');
 51 |         return next();
 52 |     });
 53 | 
 54 |     app.use(bodyParser.json({
 55 |       strict: false,
 56 |       type: '*/*'    
 57 |     }));
 58 |     var oThis = this;
 59 |     app.get("/", function(req, res){
 60 |       oThis.getConnection(req);
 61 |       if(!req.query.con){
 62 |         return res.status(500).send("Missing parameter `con` with connection details. "
 63 |         + "Example: con=mssql://dbuser:dbpwd@sqlserver/databasename");
 64 |       }
 65 |       oThis.execCommand({url: req.query.con, type:'test'})
 66 |         .then(data => res.send(data))
 67 |         .catch(err => 
 68 |           res.status(500).send(err));
 69 |     });
 70 |     app.post("/*", function(req, res){
 71 |       oThis.getConnection(req);
 72 |       oThis.execCommand(req.body)
 73 |         .then(data => res.send(data))
 74 |         .catch(err => 
 75 |           res.status(500).send(err));
 76 |     });
 77 |     
 78 |     var port = process.argv[2] || 666;
 79 |     app.listen(port);
 80 |     console.log("Server is listening to port " + port);
 81 |   }
 82 | 
 83 | SQLProxyServer.prototype.API = function(command){
 84 |     var _api = this;
 85 |     _api.cmd = command;
 86 |     
 87 |     _api.execute = function(){
 88 |       return (_api[_api.cmd.type] || _api.default)();
 89 |     }
 90 | 
 91 |     _api.default = function(){
 92 |       return q.reject("Invalid command " + _api.cmd.type);
 93 |     }
 94 |     
 95 |     _api.test = function(){
 96 |       return _api.cmd.provider.query("SELECT 1;")
 97 |                 .then(r => {return{status:'sucess'}})
 98 |                 .catch(_api.internals.error);
 99 |     };
100 |     
101 |     _api.query = function(){
102 |       var queries = 
103 |             _api.cmd.body.targets.map(t => {
104 |               return _api.cmd.provider.query(t.target, _.assignIn({}, _api.cmd.body.range, t))
105 |                 .then(r => 
106 |                   _api.internals.parse(_api.cmd, t, r).results
107 |                 )});
108 |       return q.all(queries)
109 |         .then(_.concat)
110 |         .then(_.flatten);
111 |     }
112 |     
113 |     _api.search = function(){
114 |       /**
115 |        * Example array response
116 |        * ["upper_25","upper_50","upper_75","upper_90","upper_95"]
117 |        * Example map response
118 |        * [ { "text" :"upper_25", "value": 1}, { "text" :"upper_75", "value": 2} ]
119 |        */
120 |       _api.cmd.body.targets = [{
121 |         target: _api.cmd.body.target,
122 |         type: 'search'
123 |       }];
124 |       return _api.query();
125 |     }
126 |     
127 |     _api.annotations = function(){
128 |       _api.cmd.body.targets = [{
129 |         target: _api.cmd.body.annotation.query,
130 |         annotation: _api.cmd.body.annotation,
131 |         type: 'annotations'
132 |       }];
133 |       return _api.query();
134 |     }
135 |     
136 |     _api.internals = {
137 |       try: (fnc)=>{
138 |         try{
139 |           return fnc();
140 |         }catch(e){ 
141 |           console.error(e);
142 |           return e;
143 |         }
144 |       },
145 |       parse: (reqData, target, results)=>{
146 |         if(target.type == "timeseries")
147 |             return _api.internals.try(() => _api.internals.parseTimeseries(target, results));
148 |         if(target.type == "table")
149 |             return _api.internals.try(() => _api.internals.parseTable(target, results));
150 |         if(target.type == "annotations")
151 |           return _api.internals.try(() => _api.internals.parseAnnotations(target, results));
152 |         if(target.type == "search")
153 |           return _api.internals.try(() => _api.internals.parseSearch(target, results));
154 |         return "Unsupported response type: " + target.type;  
155 |       },
156 |       parseSearch: (target, results) => {
157 |         var mapped = Object.keys(results.columns).length > 1;
158 |         if(mapped){
159 |           var textColumn = _api.internals.getColumn('text', target, results);
160 |           var valueColumn = _api.internals.getColumn('value', target, results);
161 |           target.results = results.rows.map(r => ({ "text" :r[textColumn], "value": r[valueColumn]}));
162 |         }else{
163 |           var col = Object.keys(results.columns)[0];
164 |           target.results = results.rows.map(r => r[col]);
165 |         }
166 |         return target;
167 |       },
168 |       parseAnnotations: (target, results) => {
169 |         target.timestamp = _api.internals.getTimestamp(target, results);
170 |         target.results = results.rows.map(r => _.assignIn(r, {
171 |                                                   annotation: target.annotation,
172 |                                                   time: _api.internals.utc(r[target.timestamp], target.annotation.utc).valueOf()
173 |                                                 }));
174 |         return target;
175 |       },
176 |       utc: function(value, utc){
177 |         if(utc == 'localtime' && (value && value.getTimezoneOffset)){
178 |             var dateTime = moment(value);
179 |             return dateTime.add(value.getTimezoneOffset(), 'm');
180 |         }
181 |         return value;
182 |       },
183 |       parseTimeseries: (target, results)=>{
184 |         target.timestamp = _api.internals.getTimestamp(target, results);
185 |         target.metric = _api.internals.getMetric(target, results);
186 |         target.value = _api.internals.getMetricValue(target, results);
187 |         target.results = _.map(
188 |                           _.groupBy(results.rows, target.metric),
189 |                           (v, k) => {
190 |                             return {
191 |                                 target: k,
192 |                                 datapoints: v.map(r => [r[target.value], _api.internals.utc(r[target.timestamp], target.utc).valueOf()])
193 |                             };
194 |                           });
195 |         return target;
196 |       },
197 |       parseTable: (target, results)=>{
198 |         var mapType = function(sqltype){
199 |           if(_.filter(['int', 'byte', 'decimal', 'float', 'double', 'money', 'bit',
200 |                         'numeric', 'real'],
201 |                     (sqlt) => sqltype.indexOf(sqlt) != -1).length != 0) 
202 |             return "number";
203 |           if(_.filter(['date', 'time'],
204 |                     (sqlt) => sqltype.indexOf(sqlt) != -1).length != 0) 
205 |             return "time";
206 |           return "string";
207 |         }
208 |         var columns = _.map(results.columns, (v,k) =>{
209 |             return {text:k, type:mapType(v.type.name.toLowerCase()), sqltype: v.type.name};
210 |         });
211 |         var rows = _.map(results.rows, (r) => _.map(r, (v) => v));
212 |         target.results = {columns: columns, rows: rows, type:'table'};
213 |         return target;
214 |       },
215 |       getTimestamp: (target, results)=>{
216 |         return _api.internals.getSpecialColumn(results, (k, type) =>
217 |             k == target.timestampKey ? 1000:
218 |                                 k.toLowerCase() == 'timestamp' ? 100:
219 |                                   results.columns[k].type.name == 'DateTime' ? 1: 0)
220 |       },
221 |       getMetric: (target, results)=>{
222 |         return _api.internals.getSpecialColumn(results, (k, type) => 
223 |                         k == target.metric ? 1000:
224 |                           ['metric', 'key'].indexOf(k.toLowerCase()) != -1  ? 100:
225 |                           type == 'text' || type.indexOf('char') != -1 ? 1: 0)
226 |       },
227 |       getMetricValue: (target, results)=>{
228 |         return _api.internals.getSpecialColumn(results, (k, type) => 
229 |                         k == target.value ? 1000:
230 |                           k.toLowerCase() == 'value' ? 100:
231 |                             [target.timestamp, target.metric].indexOf(k.toLowerCase()) == -1  ? 1: 0)
232 |       },
233 |       getColumn: (column, target, results)=>{
234 |         return _api.internals.getSpecialColumn(results, (k, type) => 
235 |                         k == target.metric ? 1000:
236 |                           [column].indexOf(k.toLowerCase()) != -1  ? 100:
237 |                           type == 'text' || type.indexOf('char') != -1 ? 1: 0)
238 |       },
239 |       getSpecialColumn: (results, score)=>{
240 |         return _.orderBy(Object.keys(results.columns)
241 |                     .map(k => {
242 |                         var type = results.columns[k].type.name.toLowerCase(); 
243 |                         return { key: k, score: score(k, type) }
244 |                       }),
245 |                   ['score'],
246 |                   ['desc'])[0].key
247 |         }
248 |     }
249 |     return this;
250 |   }
251 | 
252 | if (require.main === module) {
253 |     new SQLProxyServer().runStandalone();
254 | } else {
255 |     module.exports = SQLProxyServer;
256 | }
257 | 
258 |

--------------------------------------------------------------------------------
/src/serverside/sqlproxyserver.js:
--------------------------------------------------------------------------------
  1 | var _ = require("lodash");
  2 | var q = require("q");
  3 | var moment = require("moment");
  4 | 
  5 | function SQLProxyServer(providerFactory) {
  6 |     this.providerFactory = providerFactory || this.defaultProviderFactory;
  7 | }
  8 | 
  9 | SQLProxyServer.prototype.defaultProviderFactory = function(url){
 10 |     var m = /([^:]*).*/.exec(url);
 11 |     if(!m) return q.reject("Invalid connection " + url);
 12 |     try{
 13 |       return q.resolve(require('./' + m[1] + "driver.js"));
 14 |     }catch(e){
 15 |       return q.reject(e);
 16 |     }
 17 |   }
 18 | 
 19 | SQLProxyServer.prototype.loadProvider = function(req){
 20 |     return this.providerFactory(req.url)
 21 |         .then(provider => {
 22 |           req.provider = new provider(req);
 23 |           return req;
 24 |         });
 25 |   } 
 26 | 
 27 | SQLProxyServer.prototype.loadAPI = function(req){
 28 |     return this.loadProvider(req)
 29 |             .then(d => new this.API(req));
 30 |   }
 31 | 
 32 | SQLProxyServer.prototype.execCommand = function(req){
 33 |     return this.loadAPI(req)
 34 |             .then(api => api.execute());
 35 |   }
 36 | SQLProxyServer.prototype.getConnection = function(req){
 37 |     var consrc = [/\??con\=(.*)/.exec(req.url||"con=")[1], req.query.con, req.body.url];
 38 |     req.body.url = consrc.filter(s => s)[0];
 39 |   }
 40 | SQLProxyServer.prototype.runStandalone = function(){
 41 |     var express = require('express');
 42 |     var bodyParser = require('body-parser');
 43 |     var app = express();
 44 |     
 45 |     app.use((req, res, next)=>{
 46 |         res.setHeader('Access-Control-Allow-Origin', '*');
 47 |         res.setHeader('Access-Control-Allow-Headers', 'Origin, Accept, Accept-Version, Content-Length, Content-MD5, Content-Type, Date, X-Api-Version, X-Response-Time, X-PINGOTHER, X-CSRF-Token,Authorization');
 48 |         res.setHeader('Access-Control-Allow-Methods', '*');
 49 |         res.setHeader('Access-Control-Expose-Headers', 'X-Api-Version, X-Request-Id, X-Response-Time');
 50 |         res.setHeader('Access-Control-Max-Age', '1000');
 51 |         return next();
 52 |     });
 53 | 
 54 |     app.use(bodyParser.json({
 55 |       strict: false,
 56 |       type: '*/*'    
 57 |     }));
 58 |     var oThis = this;
 59 |     app.get("/", function(req, res){
 60 |       if(!req.query.con){
 61 |         return res.status(500).send("Missing parameter `con` with connection details. "
 62 |         + "Example: con=mssql://dbuser:dbpwd@sqlserver/databasename");
 63 |       }
 64 |       oThis.getConnection(req);
 65 |       oThis.execCommand({url: req.query.con, type:'test'})
 66 |         .then(data => res.send(data))
 67 |         .catch(err => 
 68 |           res.status(500).send(err));
 69 |     });
 70 |     app.post("/*", function(req, res){
 71 |       oThis.getConnection(req);
 72 |       oThis.execCommand(req.body)
 73 |         .then(data => res.send(data))
 74 |         .catch(err => 
 75 |           res.status(500).send(err));
 76 |     });
 77 |     
 78 |     var port = process.argv[2] || 666;
 79 |     app.listen(port);
 80 |     console.log("Server is listening to port " + port);
 81 |   }
 82 | 
 83 | SQLProxyServer.prototype.API = function(command){
 84 |     var _api = this;
 85 |     _api.cmd = command;
 86 |     
 87 |     _api.execute = function(){
 88 |       return (_api[_api.cmd.type] || _api.default)();
 89 |     }
 90 | 
 91 |     _api.default = function(){
 92 |       return q.reject("Invalid command " + _api.cmd.type);
 93 |     }
 94 |     
 95 |     _api.test = function(){
 96 |       return _api.cmd.provider.query("SELECT 1;")
 97 |                 .then(r => {return{status:'sucess'}})
 98 |                 .catch(_api.internals.error);
 99 |     };
100 |     
101 |     _api.query = function(){
102 |       var queries = 
103 |             _api.cmd.body.targets.map(t => {
104 |               return _api.cmd.provider.query(t.target, _.assignIn({}, _api.cmd.body.range, t))
105 |                 .then(r => 
106 |                   _api.internals.parse(_api.cmd, t, r).results
107 |                 )});
108 |       return q.all(queries)
109 |         .then(_.concat)
110 |         .then(_.flatten);
111 |     }
112 |     
113 |     _api.search = function(){
114 |       /**
115 |        * Example array response
116 |        * ["upper_25","upper_50","upper_75","upper_90","upper_95"]
117 |        * Example map response
118 |        * [ { "text" :"upper_25", "value": 1}, { "text" :"upper_75", "value": 2} ]
119 |        */
120 |       _api.cmd.body.targets = [{
121 |         target: _api.cmd.body.target,
122 |         type: 'search'
123 |       }];
124 |       return _api.query();
125 |     }
126 |     
127 |     _api.annotations = function(){
128 |       _api.cmd.body.targets = [{
129 |         target: _api.cmd.body.annotation.query,
130 |         annotation: _api.cmd.body.annotation,
131 |         type: 'annotations'
132 |       }];
133 |       return _api.query();
134 |     }
135 |     
136 |     _api.internals = {
137 |       try: (fnc)=>{
138 |         try{
139 |           return fnc();
140 |         }catch(e){ 
141 |           console.error(e);
142 |           return e;
143 |         }
144 |       },
145 |       parse: (reqData, target, results)=>{
146 |         if(target.type == "timeseries")
147 |             return _api.internals.try(() => _api.internals.parseTimeseries(target, results));
148 |         if(target.type == "table")
149 |             return _api.internals.try(() => _api.internals.parseTable(target, results));
150 |         if(target.type == "annotations")
151 |           return _api.internals.try(() => _api.internals.parseAnnotations(target, results));
152 |         if(target.type == "search")
153 |           return _api.internals.try(() => _api.internals.parseSearch(target, results));
154 |         return "Unsupported response type: " + target.type;  
155 |       },
156 |       parseSearch: (target, results) => {
157 |         var mapped = Object.keys(results.columns).length > 1;
158 |         if(mapped){
159 |           var textColumn = _api.internals.getColumn('text', target, results);
160 |           var valueColumn = _api.internals.getColumn('value', target, results);
161 |           target.results = results.rows.map(r => ({ "text" :r[textColumn], "value": r[valueColumn]}));
162 |         }else{
163 |           var col = Object.keys(results.columns)[0];
164 |           target.results = results.rows.map(r => r[col]);
165 |         }
166 |         return target;
167 |       },
168 |       parseAnnotations: (target, results) => {
169 |         target.timestamp = _api.internals.getTimestamp(target, results);
170 |         target.results = results.rows.map(r => _.assignIn(r, {
171 |                                                   annotation: target.annotation,
172 |                                                   time: _api.internals.utc(r[target.timestamp], target.annotation.utc).valueOf()
173 |                                                 }));
174 |         return target;
175 |       },
176 |       utc: function(value, utc){
177 |         if(utc == 'localtime' && (value && value.getTimezoneOffset)){
178 |             var dateTime = moment(value);
179 |             return dateTime.add(value.getTimezoneOffset(), 'm');
180 |         }
181 |         return value;
182 |       },
183 |       parseTimeseries: (target, results)=>{
184 |         target.timestamp = _api.internals.getTimestamp(target, results);
185 |         target.metric = _api.internals.getMetric(target, results);
186 |         target.value = _api.internals.getMetricValue(target, results);
187 |         target.results = _.map(
188 |                           _.groupBy(results.rows, target.metric),
189 |                           (v, k) => {
190 |                             return {
191 |                                 target: k,
192 |                                 datapoints: v.map(r => [r[target.value], _api.internals.utc(r[target.timestamp], target.utc).valueOf()])
193 |                             };
194 |                           });
195 |         return target;
196 |       },
197 |       parseTable: (target, results)=>{
198 |         var mapType = function(sqltype){
199 |           if(_.filter(['int', 'byte', 'decimal', 'float', 'double', 'money', 'bit',
200 |                         'numeric', 'real'],
201 |                     (sqlt) => sqltype.indexOf(sqlt) != -1).length != 0) 
202 |             return "number";
203 |           if(_.filter(['date', 'time'],
204 |                     (sqlt) => sqltype.indexOf(sqlt) != -1).length != 0) 
205 |             return "time";
206 |           return "string";
207 |         }
208 |         var columns = _.map(results.columns, (v,k) =>{
209 |             return {text:k, type:mapType(v.type.name.toLowerCase()), sqltype: v.type.name};
210 |         });
211 |         var rows = _.map(results.rows, (r) => _.map(r, (v) => v));
212 |         target.results = {columns: columns, rows: rows, type:'table'};
213 |         return target;
214 |       },
215 |       getTimestamp: (target, results)=>{
216 |         return _api.internals.getSpecialColumn(results, (k, type) =>
217 |             k == target.timestampKey ? 1000:
218 |                                 k.toLowerCase() == 'timestamp' ? 100:
219 |                                   results.columns[k].type.name == 'DateTime' ? 1: 0)
220 |       },
221 |       getMetric: (target, results)=>{
222 |         return _api.internals.getSpecialColumn(results, (k, type) => 
223 |                         k == target.metric ? 1000:
224 |                           ['metric', 'key'].indexOf(k.toLowerCase()) != -1  ? 100:
225 |                           type == 'text' || type.indexOf('char') != -1 ? 1: 0)
226 |       },
227 |       getMetricValue: (target, results)=>{
228 |         return _api.internals.getSpecialColumn(results, (k, type) => 
229 |                         k == target.value ? 1000:
230 |                           k.toLowerCase() == 'value' ? 100:
231 |                             [target.timestamp, target.metric].indexOf(k.toLowerCase()) == -1  ? 1: 0)
232 |       },
233 |       getColumn: (column, target, results)=>{
234 |         return _api.internals.getSpecialColumn(results, (k, type) => 
235 |                         k == target.metric ? 1000:
236 |                           [column].indexOf(k.toLowerCase()) != -1  ? 100:
237 |                           type == 'text' || type.indexOf('char') != -1 ? 1: 0)
238 |       },
239 |       getSpecialColumn: (results, score)=>{
240 |         return _.orderBy(Object.keys(results.columns)
241 |                     .map(k => {
242 |                         var type = results.columns[k].type.name.toLowerCase(); 
243 |                         return { key: k, score: score(k, type) }
244 |                       }),
245 |                   ['score'],
246 |                   ['desc'])[0].key
247 |         }
248 |     }
249 |     return this;
250 |   }
251 | 
252 | if (require.main === module) {
253 |     new SQLProxyServer().runStandalone();
254 | } else {
255 |     module.exports = SQLProxyServer;
256 | }
257 | 
258 |

--------------------------------------------------------------------------------