first commit

grafana/dashboards/requests/node_modules/then-request/lib/Options.d.ts

@@ -0,0 +1,30 @@
+/// <reference types="node" />
+import { Agent } from 'http';
+import { IncomingHttpHeaders } from 'http';
+import Response = require('http-response-object');
+import { ICache, CachedResponse } from 'http-basic';
+import FormData = require('form-data');
+interface Options {
+    allowRedirectHeaders?: string[];
+    cache?: 'file' | 'memory' | ICache;
+    agent?: boolean | Agent;
+    followRedirects?: boolean;
+    gzip?: boolean;
+    headers?: IncomingHttpHeaders;
+    maxRedirects?: number;
+    maxRetries?: number;
+    retry?: boolean | ((err: NodeJS.ErrnoException | null, res: Response<NodeJS.ReadableStream | Buffer | string> | void, attemptNumber: number) => boolean);
+    retryDelay?: number | ((err: NodeJS.ErrnoException | null, res: Response<NodeJS.ReadableStream | Buffer | string> | void, attemptNumber: number) => number);
+    socketTimeout?: number;
+    timeout?: number;
+    isMatch?: (requestHeaders: IncomingHttpHeaders, cachedResponse: CachedResponse, defaultValue: boolean) => boolean;
+    isExpired?: (cachedResponse: CachedResponse, defaultValue: boolean) => boolean;
+    canCache?: (res: Response<NodeJS.ReadableStream>, defaultValue: boolean) => boolean;
+    qs?: {
+        [key: string]: any;
+    };
+    json?: any;
+    form?: FormData;
+    body?: string | Buffer | NodeJS.ReadableStream;
+}
+export { Options };

grafana/dashboards/requests/node_modules/then-request/lib/Options.js

@@ -0,0 +1,2 @@
+"use strict";
+exports.__esModule = true;

grafana/dashboards/requests/node_modules/then-request/lib/Options.js.flow

@@ -0,0 +1,52 @@
+// @flow
+// Generated using flowgen2
+
+import {Agent} from 'http';
+type IncomingHttpHeaders = Object;
+const Response = require('http-response-object');
+import type {ICache} from 'http-basic';
+import type {CachedResponse} from 'http-basic';
+const FormData = require('form-data');
+
+interface Options {
+  allowRedirectHeaders?: Array<string>;
+  cache?: 'file' | 'memory' | ICache;
+  agent?: boolean | Agent;
+  followRedirects?: boolean;
+  gzip?: boolean;
+  headers?: IncomingHttpHeaders;
+  maxRedirects?: number;
+  maxRetries?: number;
+  retry?:
+    | boolean
+    | ((
+        err: ErrnoError | null,
+        res: Response<stream$Readable | Buffer | string> | void,
+        attemptNumber: number,
+      ) => boolean);
+  retryDelay?:
+    | number
+    | ((
+        err: ErrnoError | null,
+        res: Response<stream$Readable | Buffer | string> | void,
+        attemptNumber: number,
+      ) => number);
+  socketTimeout?: number;
+  timeout?: number;
+  isMatch?: (
+    requestHeaders: IncomingHttpHeaders,
+    cachedResponse: CachedResponse,
+    defaultValue: boolean,
+  ) => boolean;
+  isExpired?: (
+    cachedResponse: CachedResponse,
+    defaultValue: boolean,
+  ) => boolean;
+  canCache?: (res: Response<stream$Readable>, defaultValue: boolean) => boolean;
+  qs?: {[key: string]: any};
+  json?: any;
+  form?: FormData;
+  body?: string | Buffer | stream$Readable;
+}
+
+export type {Options};

grafana/dashboards/requests/node_modules/then-request/lib/RequestFn.d.ts

@@ -0,0 +1,5 @@
+import { HttpVerb } from 'http-basic';
+import { Options } from './Options';
+import { ResponsePromise } from './ResponsePromise';
+declare type RequestFn = (method: HttpVerb, url: string, options?: Options) => ResponsePromise;
+export { RequestFn };

grafana/dashboards/requests/node_modules/then-request/lib/RequestFn.js

@@ -0,0 +1,2 @@
+"use strict";
+exports.__esModule = true;

grafana/dashboards/requests/node_modules/then-request/lib/RequestFn.js.flow

@@ -0,0 +1,14 @@
+// @flow
+// Generated using flowgen2
+
+import type {HttpVerb} from 'http-basic';
+import type {Options} from './Options';
+import {ResponsePromise} from './ResponsePromise';
+
+type RequestFn = (
+  method: HttpVerb,
+  url: string,
+  options?: Options,
+) => ResponsePromise;
+
+export type {RequestFn};

grafana/dashboards/requests/node_modules/then-request/lib/ResponsePromise.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+import Promise = require('promise');
+import Response = require('http-response-object');
+export declare class ResponsePromise extends Promise<Response<Buffer | string>> {
+    getBody(encoding: string): Promise<string>;
+    getBody(): Promise<Buffer | string>;
+}
+declare function toResponsePromise(result: Promise<Response<Buffer | string>>): ResponsePromise;
+export default toResponsePromise;

grafana/dashboards/requests/node_modules/then-request/lib/ResponsePromise.js

@@ -0,0 +1,27 @@
+"use strict";
+exports.__esModule = true;
+var Promise = require("promise");
+function getBody(encoding) {
+    if (!encoding) {
+        return this.then(getBodyBinary);
+    }
+    if (encoding === 'utf8') {
+        return this.then(getBodyUTF8);
+    }
+    return this.then(getBodyWithEncoding(encoding));
+}
+function getBodyWithEncoding(encoding) {
+    return function (res) { return res.getBody(encoding); };
+}
+function getBodyBinary(res) {
+    return res.getBody();
+}
+function getBodyUTF8(res) {
+    return res.getBody('utf8');
+}
+function toResponsePromise(result) {
+    result.getBody = getBody;
+    return result;
+}
+exports["default"] = toResponsePromise;
+exports.ResponsePromise = undefined;

grafana/dashboards/requests/node_modules/then-request/lib/ResponsePromise.js.flow

@@ -0,0 +1,17 @@
+// @flow
+// Generated using flowgen2
+
+const Promise = require('promise');
+const Response = require('http-response-object');
+
+declare class ResponsePromise extends Promise<Response<Buffer | string>> {
+  getBody(encoding: string): Promise<string>;
+  getBody(): Promise<Buffer | string>;
+}
+export {ResponsePromise};
+
+declare function toResponsePromise(
+  result: Promise<Response<Buffer | string>>,
+): ResponsePromise;
+
+export default toResponsePromise;

grafana/dashboards/requests/node_modules/then-request/lib/browser.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import { HttpVerb } from 'http-basic/lib/HttpVerb';
+import { IncomingHttpHeaders } from 'http';
+import GenericResponse = require('http-response-object');
+import { Options } from './Options';
+import { ResponsePromise } from './ResponsePromise';
+import { RequestFn } from './RequestFn';
+declare type Response = GenericResponse<Buffer | string>;
+export { HttpVerb, IncomingHttpHeaders as Headers, Options, ResponsePromise, Response };
+declare const fd: any;
+export { fd as FormData };
+declare const _default: RequestFn;
+export default _default;

grafana/dashboards/requests/node_modules/then-request/lib/browser.js

@@ -0,0 +1,124 @@
+'use strict';
+var __assign = (this && this.__assign) || Object.assign || function(t) {
+    for (var s, i = 1, n = arguments.length; i < n; i++) {
+        s = arguments[i];
+        for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+            t[p] = s[p];
+    }
+    return t;
+};
+exports.__esModule = true;
+var GenericResponse = require("http-response-object");
+var Promise = require("promise");
+var ResponsePromise_1 = require("./ResponsePromise");
+exports.ResponsePromise = ResponsePromise_1.ResponsePromise;
+var handle_qs_1 = require("./handle-qs");
+function request(method, url, options) {
+    return ResponsePromise_1["default"](new Promise(function (resolve, reject) {
+        var xhr = new XMLHttpRequest();
+        // check types of arguments
+        if (typeof method !== 'string') {
+            throw new TypeError('The method must be a string.');
+        }
+        if (typeof url !== 'string') {
+            throw new TypeError('The URL/path must be a string.');
+        }
+        if (options == null) {
+            options = {};
+        }
+        if (typeof options !== 'object') {
+            throw new TypeError('Options must be an object (or null).');
+        }
+        method = method.toUpperCase();
+        function attempt(n, options) {
+            request(method, url, {
+                qs: options.qs,
+                headers: options.headers,
+                timeout: options.timeout
+            }).nodeify(function (err, res) {
+                var retry = !!(err || res.statusCode >= 400);
+                if (typeof options.retry === 'function') {
+                    retry = options.retry(err, res, n + 1);
+                }
+                if (n >= (options.maxRetries || 5)) {
+                    retry = false;
+                }
+                if (retry) {
+                    var delay = options.retryDelay;
+                    if (typeof options.retryDelay === 'function') {
+                        delay = options.retryDelay(err, res, n + 1);
+                    }
+                    delay = delay || 200;
+                    setTimeout(function () {
+                        attempt(n + 1, options);
+                    }, delay);
+                }
+                else {
+                    if (err)
+                        reject(err);
+                    else
+                        resolve(res);
+                }
+            });
+        }
+        if (options.retry && method === 'GET') {
+            return attempt(0, options);
+        }
+        var headers = options.headers || {};
+        // handle cross domain
+        var match;
+        var crossDomain = !!((match = /^([\w-]+:)?\/\/([^\/]+)/.exec(url)) && (match[2] != location.host));
+        if (!crossDomain) {
+            headers = __assign({}, headers, { 'X-Requested-With': 'XMLHttpRequest' });
+        }
+        // handle query string
+        if (options.qs) {
+            url = handle_qs_1["default"](url, options.qs);
+        }
+        // handle json body
+        if (options.json) {
+            options.body = JSON.stringify(options.json);
+            headers = __assign({}, headers, { 'Content-Type': 'application/json' });
+        }
+        if (options.form) {
+            options.body = options.form;
+        }
+        if (options.timeout) {
+            xhr.timeout = options.timeout;
+            var start_1 = Date.now();
+            xhr.ontimeout = function () {
+                var duration = Date.now() - start_1;
+                var err = new Error('Request timed out after ' + duration + 'ms');
+                err.timeout = true;
+                err.duration = duration;
+                reject(err);
+            };
+        }
+        xhr.onreadystatechange = function () {
+            if (xhr.readyState === 4) {
+                var headers = {};
+                xhr.getAllResponseHeaders().split('\r\n').forEach(function (header) {
+                    var h = header.split(':');
+                    if (h.length > 1) {
+                        headers[h[0].toLowerCase()] = h.slice(1).join(':').trim();
+                    }
+                });
+                var res = new GenericResponse(xhr.status, headers, xhr.responseText, url);
+                resolve(res);
+            }
+        };
+        // method, url, async
+        xhr.open(method, url, true);
+        for (var name in headers) {
+            xhr.setRequestHeader(name, headers[name]);
+        }
+        // avoid sending empty string (#319)
+        xhr.send(options.body ? options.body : null);
+    }));
+}
+var fd = FormData;
+exports.FormData = fd;
+exports["default"] = request;
+module.exports = request;
+module.exports["default"] = request;
+module.exports.FormData = fd;

grafana/dashboards/requests/node_modules/then-request/lib/browser.js.flow

@@ -0,0 +1,21 @@
+// @flow
+// Generated using flowgen2
+
+import type {HttpVerb} from 'http-basic/lib/HttpVerb';
+type IncomingHttpHeaders = Object;
+const GenericResponse = require('http-response-object');
+import type {Options} from './Options';
+import {ResponsePromise} from './ResponsePromise';
+import type {RequestFn} from './RequestFn';
+
+type Response = GenericResponse<Buffer | string>;
+
+export type {HttpVerb};
+export type {IncomingHttpHeaders as Headers};
+export type {Options};
+export {ResponsePromise};
+export type {Response};
+declare var fd: any;
+export {fd as FormData};
+declare var _default: RequestFn;
+export default _default;

grafana/dashboards/requests/node_modules/then-request/lib/handle-qs.d.ts

@@ -0,0 +1,3 @@
+export default function handleQs(url: string, query: {
+    [key: string]: any;
+}): string;

grafana/dashboards/requests/node_modules/then-request/lib/handle-qs.js

@@ -0,0 +1,18 @@
+"use strict";
+exports.__esModule = true;
+var qs_1 = require("qs");
+function handleQs(url, query) {
+    var _a = url.split('?'), start = _a[0], part2 = _a[1];
+    var qs = (part2 || '').split('#')[0];
+    var end = part2 && part2.split('#').length > 1 ? '#' + part2.split('#')[1] : '';
+    var baseQs = qs_1.parse(qs);
+    for (var i in query) {
+        baseQs[i] = query[i];
+    }
+    qs = qs_1.stringify(baseQs);
+    if (qs !== '') {
+        qs = '?' + qs;
+    }
+    return start + qs + end;
+}
+exports["default"] = handleQs;

grafana/dashboards/requests/node_modules/then-request/lib/handle-qs.js.flow

@@ -0,0 +1,5 @@
+// @flow
+// Generated using flowgen2
+
+declare function handleQs(url: string, query: {[key: string]: any}): string;
+export default handleQs;

grafana/dashboards/requests/node_modules/then-request/lib/index.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import GenericResponse = require('http-response-object');
+import { IncomingHttpHeaders } from 'http';
+import { Options } from './Options';
+import { ResponsePromise } from './ResponsePromise';
+import { RequestFn } from './RequestFn';
+import { HttpVerb } from 'http-basic';
+import FormData = require('form-data');
+declare type Response = GenericResponse<Buffer | string>;
+export { HttpVerb, IncomingHttpHeaders as Headers, Options, ResponsePromise, Response };
+export { FormData };
+declare const _default: RequestFn;
+export default _default;

grafana/dashboards/requests/node_modules/then-request/lib/index.js

@@ -0,0 +1,176 @@
+'use strict';
+var __assign = (this && this.__assign) || Object.assign || function(t) {
+    for (var s, i = 1, n = arguments.length; i < n; i++) {
+        s = arguments[i];
+        for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+            t[p] = s[p];
+    }
+    return t;
+};
+exports.__esModule = true;
+var GenericResponse = require("http-response-object");
+var Promise = require("promise");
+var concat = require("concat-stream");
+var ResponsePromise_1 = require("./ResponsePromise");
+exports.ResponsePromise = ResponsePromise_1.ResponsePromise;
+var handle_qs_1 = require("./handle-qs");
+var http_basic_1 = require("http-basic");
+var FormData = require("form-data");
+exports.FormData = FormData;
+var caseless = require('caseless');
+var basicRequest = http_basic_1["default"];
+var BufferBody = /** @class */ (function () {
+    function BufferBody(body, extraHeaders) {
+        this._body = body;
+        this._headers = extraHeaders;
+    }
+    BufferBody.prototype.getHeaders = function () {
+        return Promise.resolve(__assign({ 'content-length': '' + this._body.length }, this._headers));
+    };
+    BufferBody.prototype.pipe = function (stream) {
+        stream.end(this._body);
+    };
+    return BufferBody;
+}());
+var FormBody = /** @class */ (function () {
+    function FormBody(body) {
+        this._body = body;
+    }
+    FormBody.prototype.getHeaders = function () {
+        var _this = this;
+        var headers = this._body.getHeaders();
+        return new Promise(function (resolve, reject) {
+            var gotLength = false;
+            _this._body.getLength(function (err, length) {
+                if (gotLength)
+                    return;
+                gotLength = true;
+                if (err) {
+                    return reject(typeof err == 'string'
+                        ? new Error(err)
+                        : err);
+                }
+                headers['content-length'] = '' + length;
+                resolve(headers);
+            });
+        });
+    };
+    FormBody.prototype.pipe = function (stream) {
+        this._body.pipe(stream);
+    };
+    return FormBody;
+}());
+var StreamBody = /** @class */ (function () {
+    function StreamBody(body) {
+        this._body = body;
+    }
+    StreamBody.prototype.getHeaders = function () {
+        return Promise.resolve({});
+    };
+    StreamBody.prototype.pipe = function (stream) {
+        this._body.pipe(stream);
+    };
+    return StreamBody;
+}());
+function handleBody(options) {
+    if (options.form) {
+        return new FormBody(options.form);
+    }
+    var extraHeaders = {};
+    var body = options.body;
+    if (options.json) {
+        extraHeaders['content-type'] = 'application/json';
+        body = JSON.stringify(options.json);
+    }
+    if (typeof body === 'string') {
+        body = Buffer.from(body);
+    }
+    if (!body) {
+        body = Buffer.alloc(0);
+    }
+    if (!Buffer.isBuffer(body)) {
+        if (typeof body.pipe === 'function') {
+            return new StreamBody(body);
+        }
+        throw new TypeError('body should be a Buffer or a String');
+    }
+    return new BufferBody(body, extraHeaders);
+}
+function request(method, url, options) {
+    if (options === void 0) { options = {}; }
+    return ResponsePromise_1["default"](new Promise(function (resolve, reject) {
+        // check types of arguments
+        if (typeof method !== 'string') {
+            throw new TypeError('The method must be a string.');
+        }
+        if (typeof url !== 'string') {
+            throw new TypeError('The URL/path must be a string.');
+        }
+        if (options == null) {
+            options = {};
+        }
+        if (typeof options !== 'object') {
+            throw new TypeError('Options must be an object (or null).');
+        }
+        method = method.toUpperCase();
+        options.headers = options.headers || {};
+        var headers = caseless(options.headers);
+        // handle query string
+        if (options.qs) {
+            url = handle_qs_1["default"](url, options.qs);
+        }
+        var duplex = !(method === 'GET' || method === 'DELETE' || method === 'HEAD');
+        if (duplex) {
+            var body_1 = handleBody(options);
+            body_1.getHeaders().then(function (bodyHeaders) {
+                Object.keys(bodyHeaders).forEach(function (key) {
+                    if (!headers.has(key)) {
+                        headers.set(key, bodyHeaders[key]);
+                    }
+                });
+                ready(body_1);
+            })["catch"](reject);
+        }
+        else if (options.body) {
+            throw new Error('You cannot pass a body to a ' + method + ' request.');
+        }
+        else {
+            ready();
+        }
+        function ready(body) {
+            var req = basicRequest(method, url, {
+                allowRedirectHeaders: options.allowRedirectHeaders,
+                headers: options.headers,
+                followRedirects: options.followRedirects !== false,
+                maxRedirects: options.maxRedirects,
+                gzip: options.gzip !== false,
+                cache: options.cache,
+                agent: options.agent,
+                timeout: options.timeout,
+                socketTimeout: options.socketTimeout,
+                retry: options.retry,
+                retryDelay: options.retryDelay,
+                maxRetries: options.maxRetries,
+                isMatch: options.isMatch,
+                isExpired: options.isExpired,
+                canCache: options.canCache
+            }, function (err, res) {
+                if (err)
+                    return reject(err);
+                if (!res)
+                    return reject(new Error('No request was received'));
+                res.body.on('error', reject);
+                res.body.pipe(concat(function (body) {
+                    resolve(new GenericResponse(res.statusCode, res.headers, Array.isArray(body) ? Buffer.alloc(0) : body, res.url));
+                }));
+            });
+            if (req && body) {
+                body.pipe(req);
+            }
+        }
+    }));
+}
+exports["default"] = request;
+module.exports = request;
+module.exports["default"] = request;
+module.exports.FormData = FormData;

grafana/dashboards/requests/node_modules/then-request/lib/index.js.flow

@@ -0,0 +1,21 @@
+// @flow
+// Generated using flowgen2
+
+const GenericResponse = require('http-response-object');
+type IncomingHttpHeaders = Object;
+import type {Options} from './Options';
+import {ResponsePromise} from './ResponsePromise';
+import type {RequestFn} from './RequestFn';
+import type {HttpVerb} from 'http-basic';
+const FormData = require('form-data');
+
+type Response = GenericResponse<Buffer | string>;
+
+export type {HttpVerb};
+export type {IncomingHttpHeaders as Headers};
+export type {Options};
+export {ResponsePromise};
+export type {Response};
+export {FormData};
+declare var _default: RequestFn;
+export default _default;