@budibase/server 1.0.27-alpha.0 → 1.0.27

package/dist/integrations/rest.js

@@ -10,54 +10,18 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const datasource_1 = require("../definitions/datasource");
-const BodyTypes = {
-    NONE: "none",
-    FORM_DATA: "form",
-    XML: "xml",
-    ENCODED: "encoded",
-    JSON: "json",
-    TEXT: "text",
-};
-const coreFields = {
-    path: {
-        type: datasource_1.DatasourceFieldTypes.STRING,
-        display: "URL",
-    },
-    queryString: {
-        type: datasource_1.DatasourceFieldTypes.STRING,
-    },
-    headers: {
-        type: datasource_1.DatasourceFieldTypes.OBJECT,
-    },
-    enabledHeaders: {
-        type: datasource_1.DatasourceFieldTypes.OBJECT,
-    },
-    requestBody: {
-        type: datasource_1.DatasourceFieldTypes.JSON,
-    },
-    bodyType: {
-        type: datasource_1.DatasourceFieldTypes.STRING,
-        enum: Object.values(BodyTypes),
-    },
-};
 var RestModule;
 (function (RestModule) {
     const fetch = require("node-fetch");
-    const { formatBytes } = require("../utilities");
-    const { performance } = require("perf_hooks");
-    const FormData = require("form-data");
-    const { URLSearchParams } = require("url");
-    const { parseStringPromise: xmlParser, Builder: XmlBuilder } = require("xml2js");
     const SCHEMA = {
         docs: "https://github.com/node-fetch/node-fetch",
-        description: "With the REST API datasource, you can connect, query and pull data from multiple REST APIs. You can then use the retrieved data to build apps.",
+        description: "Representational state transfer (REST) is a de-facto standard for a software architecture for interactive applications that typically use multiple Web services. ",
         friendlyName: "REST API",
         datasource: {
             url: {
                 type: datasource_1.DatasourceFieldTypes.STRING,
-                default: "",
-                required: false,
-                deprecated: true,
+                default: "localhost",
+                required: true,
             },
             defaultHeaders: {
                 type: datasource_1.DatasourceFieldTypes.OBJECT,
@@ -70,228 +34,174 @@ var RestModule;
                 readable: true,
                 displayName: "POST",
                 type: datasource_1.QueryTypes.FIELDS,
-                fields: coreFields,
+                urlDisplay: true,
+                fields: {
+                    path: {
+                        type: datasource_1.DatasourceFieldTypes.STRING,
+                    },
+                    queryString: {
+                        type: datasource_1.DatasourceFieldTypes.STRING,
+                    },
+                    headers: {
+                        type: datasource_1.DatasourceFieldTypes.OBJECT,
+                    },
+                    requestBody: {
+                        type: datasource_1.DatasourceFieldTypes.JSON,
+                    },
+                },
             },
             read: {
                 displayName: "GET",
                 readable: true,
                 type: datasource_1.QueryTypes.FIELDS,
-                fields: coreFields,
+                urlDisplay: true,
+                fields: {
+                    path: {
+                        type: datasource_1.DatasourceFieldTypes.STRING,
+                    },
+                    queryString: {
+                        type: datasource_1.DatasourceFieldTypes.STRING,
+                    },
+                    headers: {
+                        type: datasource_1.DatasourceFieldTypes.OBJECT,
+                    },
+                },
             },
             update: {
                 displayName: "PUT",
                 readable: true,
                 type: datasource_1.QueryTypes.FIELDS,
-                fields: coreFields,
+                urlDisplay: true,
+                fields: {
+                    path: {
+                        type: datasource_1.DatasourceFieldTypes.STRING,
+                    },
+                    queryString: {
+                        type: datasource_1.DatasourceFieldTypes.STRING,
+                    },
+                    headers: {
+                        type: datasource_1.DatasourceFieldTypes.OBJECT,
+                    },
+                    requestBody: {
+                        type: datasource_1.DatasourceFieldTypes.JSON,
+                    },
+                },
             },
             patch: {
                 displayName: "PATCH",
                 readable: true,
                 type: datasource_1.QueryTypes.FIELDS,
-                fields: coreFields,
+                urlDisplay: true,
+                fields: {
+                    path: {
+                        type: datasource_1.DatasourceFieldTypes.STRING,
+                    },
+                    queryString: {
+                        type: datasource_1.DatasourceFieldTypes.STRING,
+                    },
+                    headers: {
+                        type: datasource_1.DatasourceFieldTypes.OBJECT,
+                    },
+                    requestBody: {
+                        type: datasource_1.DatasourceFieldTypes.JSON,
+                    },
+                },
             },
             delete: {
                 displayName: "DELETE",
                 type: datasource_1.QueryTypes.FIELDS,
-                fields: coreFields,
+                urlDisplay: true,
+                fields: {
+                    path: {
+                        type: datasource_1.DatasourceFieldTypes.STRING,
+                    },
+                    queryString: {
+                        type: datasource_1.DatasourceFieldTypes.STRING,
+                    },
+                    headers: {
+                        type: datasource_1.DatasourceFieldTypes.OBJECT,
+                    },
+                    requestBody: {
+                        type: datasource_1.DatasourceFieldTypes.JSON,
+                    },
+                },
             },
         },
     };
     class RestIntegration {
         constructor(config) {
             this.headers = {};
-            this.startTimeMs = performance.now();
             this.config = config;
         }
         parseResponse(response) {
             return __awaiter(this, void 0, void 0, function* () {
-                let data, raw, headers;
-                const contentType = response.headers.get("content-type") || "";
-                try {
-                    if (contentType.includes("application/json")) {
-                        data = yield response.json();
-                        raw = JSON.stringify(data);
-                    }
-                    else if (contentType.includes("text/xml") ||
-                        contentType.includes("application/xml")) {
-                        const rawXml = yield response.text();
-                        data =
-                            (yield xmlParser(rawXml, {
-                                explicitArray: false,
-                                trim: true,
-                                explicitRoot: false,
-                            })) || {};
-                        // there is only one structure, its an array, return the array so it appears as rows
-                        const keys = Object.keys(data);
-                        if (keys.length === 1 && Array.isArray(data[keys[0]])) {
-                            data = data[keys[0]];
-                        }
-                        raw = rawXml;
-                    }
-                    else {
-                        data = yield response.text();
-                        raw = data;
-                    }
+                const contentType = response.headers.get("content-type");
+                if (contentType && contentType.indexOf("application/json") !== -1) {
+                    return yield response.json();
                 }
-                catch (err) {
-                    throw "Failed to parse response body.";
+                else {
+                    return yield response.text();
                 }
-                const size = formatBytes(response.headers.get("content-length") || Buffer.byteLength(raw, "utf8"));
-                const time = `${Math.round(performance.now() - this.startTimeMs)}ms`;
-                headers = response.headers.raw();
-                for (let [key, value] of Object.entries(headers)) {
-                    headers[key] = Array.isArray(value) ? value[0] : value;
-                }
-                return {
-                    data,
-                    info: {
-                        code: response.status,
-                        size,
-                        time,
-                    },
-                    extra: {
-                        raw,
-                        headers,
-                    },
-                };
             });
         }
         getUrl(path, queryString) {
-            const main = `${path}?${queryString}`;
-            let complete = main;
-            if (this.config.url && !main.startsWith(this.config.url)) {
-                complete = !this.config.url ? main : `${this.config.url}/${main}`;
-            }
-            if (!complete.startsWith("http")) {
-                complete = `http://${complete}`;
-            }
-            return complete;
-        }
-        addBody(bodyType, body, input) {
-            let error, object, string;
-            try {
-                string = typeof body !== "string" ? JSON.stringify(body) : body;
-                object = typeof body === "object" ? body : JSON.parse(body);
-            }
-            catch (err) {
-                error = err;
-            }
-            if (!input.headers) {
-                input.headers = {};
-            }
-            switch (bodyType) {
-                case BodyTypes.NONE:
-                    break;
-                case BodyTypes.TEXT:
-                    // content type defaults to plaintext
-                    input.body = string;
-                    break;
-                case BodyTypes.ENCODED:
-                    const params = new URLSearchParams();
-                    for (let [key, value] of Object.entries(object)) {
-                        params.append(key, value);
-                    }
-                    input.body = params;
-                    break;
-                case BodyTypes.FORM_DATA:
-                    const form = new FormData();
-                    for (let [key, value] of Object.entries(object)) {
-                        form.append(key, value);
-                    }
-                    input.body = form;
-                    break;
-                case BodyTypes.XML:
-                    if (object != null) {
-                        string = (new XmlBuilder()).buildObject(object);
-                    }
-                    input.body = string;
-                    input.headers["Content-Type"] = "application/xml";
-                    break;
-                default:
-                case BodyTypes.JSON:
-                    // if JSON error, throw it
-                    if (error) {
-                        throw "Invalid JSON for request body";
-                    }
-                    input.body = string;
-                    input.headers["Content-Type"] = "application/json";
-                    break;
-            }
-            return input;
-        }
-        getAuthHeaders(authConfigId) {
-            let headers = {};
-            if (this.config.authConfigs && authConfigId) {
-                const authConfig = this.config.authConfigs.filter(c => c._id === authConfigId)[0];
-                // check the config still exists before proceeding
-                // if not - do nothing
-                if (authConfig) {
-                    let config;
-                    switch (authConfig.type) {
-                        case datasource_1.AuthType.BASIC:
-                            config = authConfig.config;
-                            headers.Authorization = `Basic ${Buffer.from(`${config.username}:${config.password}`).toString("base64")}`;
-                            break;
-                        case datasource_1.AuthType.BEARER:
-                            config = authConfig.config;
-                            headers.Authorization = `Bearer ${config.token}`;
-                            break;
-                    }
-                }
-            }
-            return headers;
+            return `${this.config.url}/${path}?${queryString}`;
         }
-        _req(query) {
+        create({ path = "", queryString = "", headers = {}, json = {} }) {
             return __awaiter(this, void 0, void 0, function* () {
-                const { path = "", queryString = "", headers = {}, method = "GET", disabledHeaders, bodyType, requestBody, authConfigId, } = query;
-                const authHeaders = this.getAuthHeaders(authConfigId);
-                this.headers = Object.assign(Object.assign(Object.assign({}, this.config.defaultHeaders), headers), authHeaders);
-                if (disabledHeaders) {
-                    for (let headerKey of Object.keys(this.headers)) {
-                        if (disabledHeaders[headerKey]) {
-                            delete this.headers[headerKey];
-                        }
-                    }
-                }
-                let input = { method, headers: this.headers };
-                if (requestBody) {
-                    input = this.addBody(bodyType, requestBody, input);
-                }
-                this.startTimeMs = performance.now();
-                const url = this.getUrl(path, queryString);
-                const response = yield fetch(url, input);
+                this.headers = Object.assign(Object.assign({}, this.config.defaultHeaders), headers);
+                const response = yield fetch(this.getUrl(path, queryString), {
+                    method: "POST",
+                    headers: this.headers,
+                    body: JSON.stringify(json),
+                });
                 return yield this.parseResponse(response);
             });
         }
-        create(opts) {
-            return __awaiter(this, void 0, void 0, function* () {
-                return this._req(Object.assign(Object.assign({}, opts), { method: "POST" }));
-            });
-        }
-        read(opts) {
+        read({ path = "", queryString = "", headers = {} }) {
             return __awaiter(this, void 0, void 0, function* () {
-                return this._req(Object.assign(Object.assign({}, opts), { method: "GET" }));
+                this.headers = Object.assign(Object.assign({}, this.config.defaultHeaders), headers);
+                const response = yield fetch(this.getUrl(path, queryString), {
+                    headers: this.headers,
+                });
+                return yield this.parseResponse(response);
             });
         }
-        update(opts) {
+        update({ path = "", queryString = "", headers = {}, json = {} }) {
             return __awaiter(this, void 0, void 0, function* () {
-                return this._req(Object.assign(Object.assign({}, opts), { method: "PUT" }));
+                this.headers = Object.assign(Object.assign({}, this.config.defaultHeaders), headers);
+                const response = yield fetch(this.getUrl(path, queryString), {
+                    method: "PUT",
+                    headers: this.headers,
+                    body: JSON.stringify(json),
+                });
+                return yield this.parseResponse(response);
             });
         }
-        patch(opts) {
+        patch({ path = "", queryString = "", headers = {}, json = {} }) {
             return __awaiter(this, void 0, void 0, function* () {
-                return this._req(Object.assign(Object.assign({}, opts), { method: "PATCH" }));
+                this.headers = Object.assign(Object.assign({}, this.config.defaultHeaders), headers);
+                const response = yield fetch(this.getUrl(path, queryString), {
+                    method: "PATCH",
+                    headers: this.headers,
+                    body: JSON.stringify(json),
+                });
+                return yield this.parseResponse(response);
             });
         }
-        delete(opts) {
+        delete({ path = "", queryString = "", headers = {} }) {
             return __awaiter(this, void 0, void 0, function* () {
-                return this._req(Object.assign(Object.assign({}, opts), { method: "DELETE" }));
+                this.headers = Object.assign(Object.assign({}, this.config.defaultHeaders), headers);
+                const response = yield fetch(this.getUrl(path, queryString), {
+                    method: "DELETE",
+                    headers: this.headers,
+                });
+                return yield this.parseResponse(response);
             });
         }
     }
     module.exports = {
         schema: SCHEMA,
         integration: RestIntegration,
-        AuthType: datasource_1.AuthType,
     };
 })(RestModule || (RestModule = {}));

package/dist/package.json

@@ -69,7 +69,6 @@
     "author": "Budibase",
     "license": "GPL-3.0",
     "dependencies": {
-        "@apidevtools/swagger-parser": "^10.0.3",
         "@budibase/auth": "^1.0.26",
         "@budibase/client": "^1.0.26",
         "@budibase/string-templates": "^1.0.26",
@@ -86,15 +85,12 @@
         "bull": "^3.22.4",
         "chmodr": "1.2.0",
         "csvtojson": "2.0.10",
-        "curlconverter": "^3.21.0",
         "dotenv": "8.2.0",
         "download": "8.0.0",
         "fix-path": "3.0.0",
-        "form-data": "^4.0.0",
         "fs-extra": "8.1.0",
         "jimp": "0.16.1",
         "joi": "17.2.1",
-        "js-yaml": "^4.1.0",
         "jsonschema": "1.4.0",
         "knex": "^0.95.6",
         "koa": "2.7.0",
@@ -127,7 +123,6 @@
         "validate.js": "0.13.1",
         "vm2": "^3.9.3",
         "worker-farm": "^1.7.0",
-        "xml2js": "^0.4.23",
         "yargs": "13.2.4",
         "zlib": "1.0.5"
     },
@@ -151,7 +146,6 @@
         "eslint": "^6.8.0",
         "jest": "^27.0.5",
         "nodemon": "^2.0.4",
-        "openapi-types": "^9.3.1",
         "path-to-regexp": "^6.2.0",
         "prettier": "^2.3.1",
         "rimraf": "^3.0.2",

package/dist/threads/query.js

@@ -22,12 +22,6 @@ function formatResponse(resp) {
     }
     return resp;
 }
-function hasExtraData(response) {
-    return (typeof response === "object" &&
-        !Array.isArray(response) &&
-        response.data != null &&
-        response.info != null);
-}
 function runAndTransform(datasource, queryVerb, query, transformer) {
     return __awaiter(this, void 0, void 0, function* () {
         const Integration = integrations[datasource.source];
@@ -35,13 +29,7 @@ function runAndTransform(datasource, queryVerb, query, transformer) {
             throw "Integration type does not exist.";
         }
         const integration = new Integration(datasource.config);
-        let output = formatResponse(yield integration[queryVerb](query));
-        let rows = output, info = undefined, extra = undefined;
-        if (hasExtraData(output)) {
-            rows = output.data;
-            info = output.info;
-            extra = output.extra;
-        }
+        let rows = formatResponse(yield integration[queryVerb](query));
         // transform as required
         if (transformer) {
             const runner = new ScriptRunner(transformer, { data: rows });
@@ -60,7 +48,7 @@ function runAndTransform(datasource, queryVerb, query, transformer) {
         if (integration.end) {
             integration.end();
         }
-        return { rows, keys, info, extra };
+        return { rows, keys };
     });
 }
 module.exports = (input, callback) => {