heimdall-api-platform 1.0.5 → 1.0.7

package/lib/commons-const.js

@@ -1,203 +0,0 @@
-module.exports = {
-    OPERATION_RESULT_IS_ORCHESTRATION_RESULT: ".",
-    NOT_IMPLEMENTED_FUNCTION: "NotImplementedFunction",
-    DEFAULT_ENCODE_UTF8: "utf-8",
-    DEFAULT_TIMEOUT_MS: 300000,
-    DEFAULT_POOLSIZE: Infinity,
-    DEFAULT_ERROR_CODE: 500,
-    DEFAULT_CONTENT_TYPE_VALUE: "text/html;charset=UTF-8",
-    STREAM_CONTENT_TYPE_VALUE: "application/octet-stream",
-    JSON_CONTENT_TYPE_VALUE: "application/json",
-    FORM_CONTENT_TYPE_VALUE: "application/x-www-form-urlencoded",
-    FORM_MULTIPART_CONTENT_TYPE_VALUE: "multipart/form-data",
-    OBJECT_TYPE: {
-        READSTREAM: "ReadStream",
-        PASSTHROUGH: "PassThrough",
-        BUFFER: "Buffer",
-        OBJECT: "Object",
-        STRING: "String",
-    },
-    FLOW_OPERATION_TYPE: {
-        HTTP: "http",
-        FUNCTION: "function",
-        MOCK: "mock",
-        MONITOR_CHECK: "monitor",
-    },
-    HTTP_STATUS: {
-        // 1xx Informational
-        CONTINUE: 100,
-        SWITCHING_PROTOCOLS: 101,
-        PROCESSING: 102,
-        CHECKPOINT: 103,
-        OK: 200,
-        CREATED: 201,
-        ACCEPTED: 202,
-        NON_AUTHORITATIVE_INFORMATIO: 203,
-        NO_CONTENT: 204,
-        RESET_CONTENT: 205,
-        PARTIAL_CONTENT: 206,
-        MULTI_STATUS: 207,
-        ALREADY_REPORTED: 208,
-        IM_USED: 226,
-        MULTIPLE_CHOICES: 300,
-        MOVED_PERMANENTLY: 301,
-        FOUND: 302,
-        MOVED_TEMPORARILY: 302,
-        SEE_OTHER: 303,
-        NOT_MODIFIED: 304,
-        USE_PROXY: 305,
-        TEMPORARY_REDIRECT: 307,
-        PERMANENT_REDIRECT: 308,
-        // --- 4xx Client Error ---
-        ERROR_CLIENT_RANGE_START: 400,
-        BAD_REQUEST: 400,
-        UNAUTHORIZED: 401,
-        PAYMENT_REQUIRED: 402,
-        FORBIDDEN: 403,
-        NOT_FOUND: 404,
-        METHOD_NOT_ALLOWED: 405,
-        NOT_ACCEPTABLE: 406,
-        PROXY_AUTHENTICATION_REQUIRED: 407,
-        REQUEST_TIMEOUT: 408,
-        CONFLICT: 409,
-        GONE: 410,
-        LENGTH_REQUIRED: 411,
-        PRECONDITION_FAILED: 412,
-        PAYLOAD_TOO_LARGE: 413,
-        REQUEST_ENTITY_TOO_LARGE: 413,
-        URI_TOO_LONG: 414,
-        REQUEST_URI_TOO_LONG: 414,
-        UNSUPPORTED_MEDIA_TYPE: 415,
-        REQUESTED_RANGE_NOT_SATISFIABLE: 416,
-        EXPECTATION_FAILED: 417,
-        I_AM_A_TEAPOT: 418,
-        INSUFFICIENT_SPACE_ON_RESOURCE: 419,
-        METHOD_FAILURE: 420,
-        DESTINATION_LOCKED: 421,
-        UNPROCESSABLE_ENTITY: 422,
-        LOCKED: 423,
-        FAILED_DEPENDENCY: 424,
-        UPGRADE_REQUIRED: 426,
-        PRECONDITION_REQUIRED: 428,
-        TOO_MANY_REQUESTS: 429,
-        REQUEST_HEADER_FIELDS_TOO_LARGE: 431,
-        UNAVAILABLE_FOR_LEGAL_REASONS: 451,
-        // --- 5xx Server Error ---
-        INTERNAL_SERVER_ERROR: 500,
-        NOT_IMPLEMENTED: 501,
-        BAD_GATEWAY: 502,
-        SERVICE_UNAVAILABLE: 503,
-        GATEWAY_TIMEOUT: 504,
-        HTTP_VERSION_NOT_SUPPORTED: 505,
-        VARIANT_ALSO_NEGOTIATES: 506,
-        INSUFFICIENT_STORAGE: 507,
-        LOOP_DETECTED: 508,
-        BANDWIDTH_LIMIT_EXCEEDED: 509,
-        NOT_EXTENDED: 510,
-        NETWORK_AUTHENTICATION_REQUIRED: 511,
-    },
-    HTTP_METHOD: {
-        GET: "GET",
-        HEAD: "HEAD",
-        POST: "POST",
-        PUT: "PUT",
-        PATCH: "PATCH",
-        DELETE: "DELETE",
-        OPTIONS: "OPTIONS",
-        TRACE: "TRACE",
-    },
-    HEADERS: {
-        X_USER_TYPE: "x-user-type",
-        X_REQUEST_UUID_NAME: "x-request-uuid",
-        X_REQUEST_SERVICE_NAME: "x-service-name",
-        X_REQUEST_SERVICE_DESCRIPTION: "x-service-description",
-        X_REQUEST_DURATION_NAME: "x-request-duration",
-        X_CUSTOMER_UUID_NAME: "x-customer-uuid",
-        X_WHITE_LABEL_UUID_NAME: "x-white-label-uuid",
-        X_ACCESS_TOKEN_NAME: "x-access-token",
-        X_AUTHORIZATION_NAME: "x-authorization",
-        X_DEVICE_DNA_NAME: "x-device-dna",
-        X_DEVICE_PUBLIC_KEY_NAME: "x-device-public-key",
-        X_VTEX_API_APPKEY_NAME: "x-vtex-api-appkey",
-        X_VTEX_API_APPTOKEN_NAME: "x-vtex-api-apptoken",
-        X_MERCHANT_ID: "x-merchant-id",
-        ACCEPT: "Accept",
-        ACCEPT_CHARSET: "Accept-Charset",
-        ACCEPT_ENCODING: "Accept-Encoding",
-        ACCEPT_LANGUAGE: "Accept-Language",
-        ACCEPT_RANGES: "Accept-Ranges",
-        ACCESS_CONTROL_ALLOW_CREDENTIALS: "Access-Control-Allow-Credentials",
-        ACCESS_CONTROL_ALLOW_HEADERS: "Access-Control-Allow-Headers",
-        ACCESS_CONTROL_ALLOW_METHODS: "Access-Control-Allow-Methods",
-        ACCESS_CONTROL_ALLOW_ORIGIN: "Access-Control-Allow-Origin",
-        ACCESS_CONTROL_EXPOSE_HEADERS: "Access-Control-Expose-Headers",
-        ACCESS_CONTROL_MAX_AGE: "Access-Control-Max-Age",
-        ACCESS_CONTROL_REQUEST_HEADERS: "Access-Control-Request-Headers",
-        ACCESS_CONTROL_REQUEST_METHOD: "Access-Control-Request-Method",
-        AGE: "Age",
-        ALLOW: "Allow",
-        AUTHORIZATION: "Authorization",
-        CACHE_CONTROL: "Cache-Control",
-        CONNECTION: "Connection",
-        CONTENT_ENCODING: "Content-Encoding",
-        CONTENT_DISPOSITION: "Content-Disposition",
-        CONTENT_LANGUAGE: "Content-Language",
-        CONTENT_LENGTH: "Content-Length",
-        CONTENT_LOCATION: "Content-Location",
-        CONTENT_RANGE: "Content-Range",
-        CONTENT_TYPE: "Content-Type",
-        COOKIE: "Cookie",
-        DATE: "Date",
-        ETAG: "ETag",
-        EXPECT: "Expect",
-        EXPIRES: "Expires",
-        FROM: "From",
-        HOST: "Host",
-        IF_MATCH: "If-Match",
-        IF_MODIFIED_SINCE: "If-Modified-Since",
-        IF_NONE_MATCH: "If-None-Match",
-        IF_RANGE: "If-Range",
-        IF_UNMODIFIED_SINCE: "If-Unmodified-Since",
-        LAST_MODIFIED: "Last-Modified",
-        LINK: "Link",
-        LOCATION: "Location",
-        MAX_FORWARDS: "Max-Forwards",
-        ORIGIN: "Origin",
-        PRAGMA: "Pragma",
-        PROXY_AUTHENTICATE: "Proxy-Authenticate",
-        PROXY_AUTHORIZATION: "Proxy-Authorization",
-        RANGE: "Range",
-        REFERER: "Referer",
-        RETRY_AFTER: "Retry-After",
-        SERVER: "Server",
-        SET_COOKIE: "Set-Cookie",
-        SET_COOKIE2: "Set-Cookie2",
-        TE: "TE",
-        TRAILER: "Trailer",
-        TRANSFER_ENCODING: "Transfer-Encoding",
-        UPGRADE: "Upgrade",
-        USER_AGENT: "User-Agent",
-        VARY: "Vary",
-        VIA: "Via",
-        WARNING: "Warning",
-        WWW_AUTHENTICATE: "WWW-Authenticate",
-    },
-    ALLOW_HEADERS_DEFAULT: [
-        "authorization",
-        "content-type",
-        "accept",
-        "accept-version",
-        "api-version",
-        "origin",
-        "vtexidclientautcookie",
-        "x-authorization",
-        "x-vtex-api-appkey",
-        "x-vtex-api-apptoken",
-        "x-access-token",
-        "x-device-public-key",
-        "x-pay2b-client-id",
-        "sentry-trace",
-        "x-merchant-id",
-        "x-customer-uuid",
-    ],
-};

package/lib/commons-elasticsearch.js

@@ -1,49 +0,0 @@
-"use strict";
-
-const Util = require("./commons-util");
-const { Client } = require("elasticsearch");
-const HOST_DEFAULT = "localhost:9200";
-
-class ElasticSearch {
-    constructor(options) {
-        this.instance = null;
-        this.enabled = options.hasOwnProperty("enableElasticSearch") ? options.enableElasticSearch : false;
-
-        if (this.enabled) {
-            let hasConfig = options.hasOwnProperty("elasticSearch");
-
-            if (hasConfig) {
-                Util.info("Creating ElasticSearch Instance", Util.stringifyInfo(options.elasticSearch));
-
-                let elasticSearch = options.elasticSearch;
-
-                const clientConfig = {
-                    host: elasticSearch.host || HOST_DEFAULT
-                };
-
-                if (elasticSearch.user && elasticSearch.password) {
-                    clientConfig.auth = {
-                        username: elasticSearch.user,
-                        password: elasticSearch.password
-                    };
-                }
-
-                this.instance = new Client(clientConfig);
-            }
-        } else {
-            this.enabled = false;
-        }
-    }
-
-    getInstance() {
-        return this.instance;
-    }
-
-    isEnabled() {
-        return this.enabled;
-    }
-}
-
-exports.createClient = function (options) {
-    return new ElasticSearch(options);
-};

package/lib/commons-errors.js

@@ -1,278 +0,0 @@
-"use strict";
-
-const Util = require("./commons-util");
-const Const = require("./commons-const");
-
-const BAD_REQUEST = 400,
-    UNAUTHORIZED_ERROR_CODE = 401,
-    FORBIDDEN_ERROR_CODE = 403,
-    NOT_FOUND_ERROR_CODE = 404,
-    ENOTFOUND_ERROR = "ENOTFOUND",
-    ETIMEDOUT_ERROR = "ETIMEDOUT",
-    REQUEST_TOO_MANY_REQUESTS = 429,
-    REQUEST_TOO_MANY_REQUESTS_MESSAGE = "Too Many Requests.",
-    REQUEST_TIMEOUT_ERROR_CODE = 408,
-    NOT_ACCEPTABLE_ERROR_CODE = 406,
-    UNAVAILABLE_ERROR_CODE = 503,
-    INTERNAL_SERVER_ERROR_CODE = 500,
-    DEFAULT_ERROR = "default",
-    DEFAULT_SECURITY_ERROR_MESSAGE = "Request Unauthorized.",
-    DEFAULT_VALIDATION_ERROR_MESSAGE = "Invalid Arguments.",
-    DEFAULT_NOT_FOUND_MESSAGE = "Not Found.",
-    DEFAULT_REQUEST_TIMEOUT_MESSAGE = "Request Timeout.",
-    DEFAULT_ERROR_MESSAGE = "Error processing the Request.",
-    DEFAULT_HANDLERS = {
-        [BAD_REQUEST]: (error) => {
-            return Errors.handleValidationError(error, BAD_REQUEST);
-        },
-        [UNAUTHORIZED_ERROR_CODE]: (error) => {
-            return Errors.handleSecurityError(error, UNAUTHORIZED_ERROR_CODE);
-        },
-        [FORBIDDEN_ERROR_CODE]: (error) => {
-            return Errors.handleSecurityError(error, FORBIDDEN_ERROR_CODE);
-        },
-        [NOT_FOUND_ERROR_CODE]: (error) => {
-            return Errors.handleNotFoundError(error);
-        },
-        [ENOTFOUND_ERROR]: (error) => {
-            return Errors.handleNotFoundError(error);
-        },
-        [NOT_ACCEPTABLE_ERROR_CODE]: (error) => {
-            return Errors.handleValidationError(error, NOT_ACCEPTABLE_ERROR_CODE);
-        },
-        [UNAVAILABLE_ERROR_CODE]: (error) => {
-            return Errors.handleDefaultError(error);
-        },
-        [REQUEST_TIMEOUT_ERROR_CODE]: (error) => {
-            return Errors.handleRequestTimeoutError(error, REQUEST_TIMEOUT_ERROR_CODE);
-        },
-        [ETIMEDOUT_ERROR]: (error) => {
-            return Errors.handleRequestTimeoutError(error, REQUEST_TIMEOUT_ERROR_CODE);
-        },
-        [DEFAULT_ERROR]: (error) => {
-            return Errors.handleDefaultError(error);
-        },
-    };
-
-function validateCause(cause) {
-    if (cause) {
-        if (cause instanceof TypeError || cause instanceof ReferenceError) {
-            return {
-                name: cause.name,
-                message: cause.message,
-                stack: cause.stack,
-            };
-        } else {
-            return cause.hasOwnProperty("message") ? cause.message : cause;
-        }
-    }
-
-    return null;
-}
-
-class BaseError extends Error {
-    constructor(message, cause) {
-        super();
-    }
-}
-
-class ApiGatewayError extends BaseError {
-    constructor(message, cause) {
-        super();
-        this.name = "ApiGatewayError";
-        this.propagable = true;
-        this.responseCode = INTERNAL_SERVER_ERROR_CODE;
-        this.message = message || DEFAULT_ERROR_MESSAGE;
-        this.cause = validateCause(cause);
-        Error.captureStackTrace(this, ApiGatewayError);
-    }
-}
-
-class ValidationError extends BaseError {
-    constructor(message, cause, responseCode) {
-        super();
-        this.name = "ValidationError";
-        this.propagable = true;
-        this.responseCode = responseCode || BAD_REQUEST;
-        this.message = message || DEFAULT_VALIDATION_ERROR_MESSAGE;
-        this.cause = validateCause(cause);
-        Error.captureStackTrace(this, ValidationError);
-    }
-}
-
-class SecurityError extends BaseError {
-    constructor(message, cause, responseCode) {
-        super();
-        this.name = "SecurityError";
-        this.propagable = true;
-        this.responseCode = responseCode || UNAUTHORIZED_ERROR_CODE;
-        this.message = message || DEFAULT_SECURITY_ERROR_MESSAGE;
-        this.cause = validateCause(cause);
-        Error.captureStackTrace(this, SecurityError);
-    }
-}
-
-class NotFoundError extends BaseError {
-    constructor(message, cause) {
-        super();
-        this.name = "NotFoundError";
-        this.propagable = true;
-        this.responseCode = NOT_FOUND_ERROR_CODE;
-        this.message = message || DEFAULT_NOT_FOUND_MESSAGE;
-        this.cause = validateCause(cause);
-        Error.captureStackTrace(this, NotFoundError);
-    }
-}
-
-class RequestTimeoutError extends BaseError {
-    constructor(message, cause) {
-        super();
-        this.name = "RequestTimeout";
-        this.propagable = true;
-        this.responseCode = REQUEST_TIMEOUT_ERROR_CODE;
-        this.message = message || DEFAULT_REQUEST_TIMEOUT_MESSAGE;
-        this.cause = validateCause(cause);
-        Error.captureStackTrace(this, RequestTimeoutError);
-    }
-}
-
-class RequestTooManyRequests extends BaseError {
-    constructor(message, cause) {
-        super();
-        this.name = "RequestTooManyRequests";
-        this.propagable = true;
-        this.responseCode = REQUEST_TOO_MANY_REQUESTS;
-        this.message = message || REQUEST_TOO_MANY_REQUESTS_MESSAGE;
-        this.cause = validateCause(cause);
-        Error.captureStackTrace(this, RequestTooManyRequests);
-    }
-}
-
-class Errors {
-
-    static handlers() {
-        return DEFAULT_HANDLERS;
-    }
-
-    static handleError(error) {
-
-        if (error instanceof BaseError) return error;
-
-        let errorCode = DEFAULT_ERROR;
-
-        if (error.hasOwnProperty("code")) errorCode = error.code;
-
-        if (error.hasOwnProperty("responseCode")) errorCode = error.responseCode;
-
-        let handler = this.handlers()[errorCode];
-
-        if (handler) {
-            return handler(error);
-        } else {
-            return this.handleDefaultError(error);
-        }
-
-    }
-
-    static handleSecurityError(error, responseCode) {
-        return new SecurityError(DEFAULT_SECURITY_ERROR_MESSAGE, error, responseCode);
-    }
-
-    static handleValidationError(error, responseCode) {
-        return new ValidationError(DEFAULT_VALIDATION_ERROR_MESSAGE, error, responseCode);
-    }
-
-    static handleNotFoundError(error) {
-        return new NotFoundError(DEFAULT_NOT_FOUND_MESSAGE, error);
-    }
-
-    static handleRequestTimeoutError(error) {
-        return new RequestTimeoutError(DEFAULT_REQUEST_TIMEOUT_MESSAGE, error);
-    }
-
-    static handleDefaultError(error) {
-        return new ApiGatewayError(DEFAULT_ERROR_MESSAGE, error);
-    }
-}
-
-function createFunctionError(error) {
-
-    if (error instanceof BaseError) return error;
-
-    let defaultError = {
-        responseCode: INTERNAL_SERVER_ERROR_CODE,
-        message: (error || {}).hasOwnProperty("message") ? error.message : DEFAULT_ERROR_MESSAGE,
-        stack: (error || {}).hasOwnProperty("stack") ? error.stack : error,
-    };
-
-    return defaultError;
-
-}
-
-function createHttpError(error) {
-
-    let defaultError = createCustomError(INTERNAL_SERVER_ERROR_CODE, DEFAULT_ERROR_MESSAGE);
-
-    if (error.hasOwnProperty("response")) {
-
-        defaultError.code = error.response.status || Const.DEFAULT_ERROR_CODE;
-        defaultError.message = error.response.data;
-
-    } else {
-
-        // let errorJSON = Util.underscore().clone(error.toJSON());
-
-        // delete errorJSON.code;
-        // delete errorJSON.config;
-        // delete errorJSON.request;
-        // delete errorJSON.status;
-        // delete errorJSON.stack;
-        // delete errorJSON.name;
-        // delete errorJSON.number;
-        // delete errorJSON.columnNumber;
-        // delete errorJSON.fileName;
-        // delete errorJSON.lineNumber;
-
-        defaultError.code = error.code || Const.DEFAULT_ERROR_CODE;
-        defaultError.message = createCustomError(
-            error.code || Const.DEFAULT_ERROR_CODE,
-            error.description || error.message
-        );
-        
-    }
-
-    return defaultError;
-
-}
-
-function createCustomError(code, message) {
-    return {
-        errors: [
-            {
-                error: code,
-                message: message,
-            },
-        ],
-    };
-}
-
-function createCustomErrors(errors) {
-    return {
-        errors: errors,
-    };
-}
-
-module.exports = {
-    ApiGatewayError: ApiGatewayError,
-    ValidationError: ValidationError,
-    SecurityError: SecurityError,
-    NotFoundError: NotFoundError,
-    RequestTimeoutError: RequestTimeoutError,
-    RequestTooManyRequests: RequestTooManyRequests,
-    Errors: Errors,
-    CreateCustomError: createCustomError,
-    CreateCustomErrors: createCustomErrors,
-    CreateHttpError: createHttpError,
-    CreateFunctionError: createFunctionError,
-    BaseError: BaseError,
-};

package/lib/commons-opensearch.js

@@ -1,37 +0,0 @@
-"use strict";
-
-const Util = require("./commons-util");
-const { Client } = require("@opensearch-project/opensearch");
-
-class OpenSearch {
-    constructor({ enableOpenSearch = false, openSearch = {} } = {}) {
-        this.enabled = enableOpenSearch;
-        this.instance = null;
-
-        if (this.enabled && openSearch.host) {
-            Util.info("Creating OpenSearch Instance", Util.stringifyInfo(openSearch));
-
-            const { host, auth = {} } = openSearch;
-            const { username, password } = auth;
-            const clientConfig = { node: host };
-
-            if (username && password) {
-                clientConfig.auth = { username, password };
-            }
-
-            this.instance = new Client(clientConfig);
-        } else {
-            this.enabled = false;
-        }
-    }
-
-    getInstance() {
-        return this.instance;
-    }
-
-    isEnabled() {
-        return this.enabled;
-    }
-}
-
-exports.createClient = (options) => new OpenSearch(options);

package/lib/commons-splunk.js

@@ -1,105 +0,0 @@
-'use strict';
-
-const Util = require('./commons-util');
-const axios = require('axios');
-const { JSON_CONTENT_TYPE_VALUE } = require('./commons-const');
-
-const DEFAULT_PROTOCOL = 'https';
-const DEFAULT_PATH = '/services/collector/event';
-const DEFAULT_PORT = '443';
-const DEFAULT_TIMEOUT = 10000;
-
-class SplunkInstance {
-
-    constructor(options) {
-
-        this.instance = null;
-
-        this.enabled = options.hasOwnProperty('enableSplunkMonitoring') ? options.enableSplunkMonitoring : false;
-
-        if (this.enabled) {
-
-            let hasConfig = options.hasOwnProperty('splunk');
-
-            if (hasConfig) {
-
-                this.token = options.splunk.auth;
-                this.host = options.splunk.host;
-
-                if (!this.host || !this.token) {
-                    Util.error(
-                        'It was not possible to create the splunk client. '
-                        + 'splunk.host and splunk.token are mandatory properties. '
-                        + 'Please inform them in your application configuration file');
-                    this.enabled = false;
-                    return;
-                }
-
-                this.protocol = options.splunk.protocol || DEFAULT_PROTOCOL;
-                this.path = options.splunk.path || DEFAULT_PATH;
-                this.port = options.splunk.port || DEFAULT_PORT;
-                this.timeout = options.splunk.timeout || DEFAULT_TIMEOUT;
-                this.contentType = options.splunk.contentType || JSON_CONTENT_TYPE_VALUE;
-
-                let config = {
-                    baseURL: `${this.protocol}://${this.host}:${this.port}`,
-                    headers: {
-                        'Authorization': `Splunk ${this.token}`,
-                        'Content-Type': this.contentType
-                    },
-                }
-
-                this.instance = axios.create(config);
-
-                Util.info('Creating Splunk Instance', Util.stringifyInfo(options.splunk));
-
-            } else {
-                this.enabled = false;
-            };
-
-        };
-
-    };
-
-    getInstance() {
-        return this.instance;
-    };
-
-    isEnabled() {
-        return this.enabled;
-    };
-
-    async sendEvent(body, currentAttempt = 1) {
-
-        if (currentAttempt >= 10) {
-            return;
-        }
-
-        this.instance.post(this.path, body,
-            { timeout: this.timeout })
-            .then(function (response) {
-                Util.info('Splunk Data Indexed Successfully', { eventId: body.event.id });
-            })
-            .catch((error) => {
-
-                Util.error(`Error on Send Event Data to Splunk: ${JSON.stringify(error)} attempt no: ${currentAttempt}`);
-
-                Util.warning('Retry Index Splunk Data', {
-                    eventId: body.event.id,
-                    retryIn: "10s x " + currentAttempt,
-                    attemptsIndex: currentAttempt
-                });
-
-                setTimeout(() => {
-                    this.sendEvent(body, ++currentAttempt);
-                }, 10000 * currentAttempt);
-
-            });
-
-    }
-
-}
-
-exports.createClient = function (options) {
-    return new SplunkInstance(options);
-};