@budibase/server 1.0.17 → 1.0.19-alpha.2

package/dist/api/controllers/{query.js → query/index.js}

@@ -9,10 +9,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 const { processString } = require("@budibase/string-templates");
-const CouchDB = require("../../db");
-const { generateQueryID, getQueryParams, isProdAppID, } = require("../../db/utils");
-const { BaseQueryVerbs } = require("../../constants");
-const { Thread, ThreadType } = require("../../threads");
+const CouchDB = require("../../../db");
+const { generateQueryID, getQueryParams, isProdAppID, } = require("../../../db/utils");
+const { BaseQueryVerbs } = require("../../../constants");
+const { Thread, ThreadType } = require("../../../threads");
+const { save: saveDatasource } = require("../datasource");
+const { RestImporter } = require("./import");
 const Runner = new Thread(ThreadType.QUERY, { timeoutMs: 10000 });
 // simple function to append "readable" to all read queries
 function enrichQueries(input) {
@@ -34,6 +36,38 @@ exports.fetch = function (ctx) {
         ctx.body = enrichQueries(body.rows.map(row => row.doc));
     });
 };
+exports.import = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
+    const body = ctx.request.body;
+    const data = body.data;
+    const importer = new RestImporter(data);
+    yield importer.init();
+    let datasourceId;
+    if (!body.datasourceId) {
+        // construct new datasource
+        const info = yield importer.getInfo();
+        let datasource = {
+            type: "datasource",
+            source: "REST",
+            config: {
+                url: info.url,
+                defaultHeaders: [],
+            },
+            name: info.name,
+        };
+        // save the datasource
+        const datasourceCtx = Object.assign({}, ctx);
+        datasourceCtx.request.body.datasource = datasource;
+        yield saveDatasource(datasourceCtx);
+        datasourceId = datasourceCtx.body.datasource._id;
+    }
+    else {
+        // use existing datasource
+        datasourceId = body.datasourceId;
+    }
+    const importResult = yield importer.importQueries(ctx.appId, datasourceId);
+    ctx.body = Object.assign(Object.assign({}, importResult), { datasourceId });
+    ctx.status = 200;
+});
 exports.save = function (ctx) {
     return __awaiter(this, void 0, void 0, function* () {
         const db = new CouchDB(ctx.appId);
@@ -78,7 +112,7 @@ function enrichQueryFields(fields, parameters = {}) {
                     enrichedQuery.requestBody);
             }
             catch (err) {
-                throw { message: `JSON Invalid - error: ${err}` };
+                // no json found, ignore
             }
             delete enrichedQuery.customData;
         }
@@ -104,7 +138,7 @@ exports.preview = function (ctx) {
         const { fields, parameters, queryVerb, transformer } = ctx.request.body;
         const enrichedQuery = yield enrichQueryFields(fields, parameters);
         try {
-            const { rows, keys } = yield Runner.run({
+            const { rows, keys, info, extra } = yield Runner.run({
                 datasource,
                 queryVerb,
                 query: enrichedQuery,
@@ -113,6 +147,8 @@ exports.preview = function (ctx) {
             ctx.body = {
                 rows,
                 schemaFields: [...new Set(keys)],
+                info,
+                extra,
             };
         }
         catch (err) {

package/dist/api/controllers/query/validation.js

@@ -0,0 +1,37 @@
+"use strict";
+const joiValidator = require("../../../middleware/joi-validator");
+const Joi = require("joi");
+exports.queryValidation = () => {
+    return Joi.object({
+        _id: Joi.string(),
+        _rev: Joi.string(),
+        name: Joi.string().required(),
+        fields: Joi.object().required(),
+        datasourceId: Joi.string().required(),
+        readable: Joi.boolean(),
+        parameters: Joi.array().items(Joi.object({
+            name: Joi.string(),
+            default: Joi.string().allow(""),
+        })),
+        queryVerb: Joi.string().allow().required(),
+        extra: Joi.object().optional(),
+        schema: Joi.object({}).required().unknown(true),
+        transformer: Joi.string().optional(),
+        flags: Joi.object().optional(),
+    });
+};
+exports.generateQueryValidation = () => {
+    // prettier-ignore
+    return joiValidator.body(exports.queryValidation());
+};
+exports.generateQueryPreviewValidation = () => {
+    // prettier-ignore
+    return joiValidator.body(Joi.object({
+        fields: Joi.object().required(),
+        queryVerb: Joi.string().allow().required(),
+        extra: Joi.object().optional(),
+        datasourceId: Joi.string().required(),
+        transformer: Joi.string().optional(),
+        parameters: Joi.object({}).required().unknown(true)
+    }));
+};

package/dist/api/controllers/user.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 const CouchDB = require("../../db");
-const { generateUserMetadataID, getUserMetadataParams, } = require("../../db/utils");
+const { generateUserMetadataID, getUserMetadataParams, generateUserFlagID, } = require("../../db/utils");
 const { InternalTables } = require("../../db/utils");
 const { getGlobalUsers, getRawGlobalUser } = require("../../utilities/global");
 const { getFullUser } = require("../../utilities/users");
@@ -189,3 +189,39 @@ exports.findMetadata = function (ctx) {
         ctx.body = yield getFullUser(ctx, ctx.params.id);
     });
 };
+exports.setFlag = function (ctx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const userId = ctx.user._id;
+        const { flag, value } = ctx.request.body;
+        if (!flag) {
+            ctx.throw(400, "Must supply a 'flag' field in request body.");
+        }
+        const flagDocId = generateUserFlagID(userId);
+        const db = new CouchDB(ctx.appId);
+        let doc;
+        try {
+            doc = yield db.get(flagDocId);
+        }
+        catch (err) {
+            doc = { _id: flagDocId };
+        }
+        doc[flag] = value || true;
+        yield db.put(doc);
+        ctx.body = { message: "Flag set successfully" };
+    });
+};
+exports.getFlags = function (ctx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const userId = ctx.user._id;
+        const docId = generateUserFlagID(userId);
+        const db = new CouchDB(ctx.appId);
+        let doc;
+        try {
+            doc = yield db.get(docId);
+        }
+        catch (err) {
+            doc = { _id: docId };
+        }
+        ctx.body = doc;
+    });
+};

package/dist/api/controllers/webhook.js

@@ -65,6 +65,10 @@ exports.buildSchema = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
         let automation = yield db.get(webhook.action.target);
         const autoOutputs = automation.definition.trigger.schema.outputs;
         let properties = webhook.bodySchema.properties;
+        // reset webhook outputs
+        autoOutputs.properties = {
+            body: autoOutputs.properties.body,
+        };
         for (let prop of Object.keys(properties)) {
             autoOutputs.properties[prop] = {
                 type: properties[prop].type,

package/dist/api/routes/query.js

@@ -2,44 +2,14 @@
 const Router = require("@koa/router");
 const queryController = require("../controllers/query");
 const authorized = require("../../middleware/authorized");
-const Joi = require("joi");
 const { PermissionLevels, PermissionTypes, BUILDER, } = require("@budibase/auth/permissions");
-const joiValidator = require("../../middleware/joi-validator");
 const { bodyResource, bodySubResource, paramResource, } = require("../../middleware/resourceId");
+const { generateQueryPreviewValidation, generateQueryValidation, } = require("../controllers/query/validation");
 const router = Router();
-function generateQueryValidation() {
-    // prettier-ignore
-    return joiValidator.body(Joi.object({
-        _id: Joi.string(),
-        _rev: Joi.string(),
-        name: Joi.string().required(),
-        fields: Joi.object().required(),
-        datasourceId: Joi.string().required(),
-        readable: Joi.boolean(),
-        parameters: Joi.array().items(Joi.object({
-            name: Joi.string(),
-            default: Joi.string().allow(""),
-        })),
-        queryVerb: Joi.string().allow().required(),
-        extra: Joi.object().optional(),
-        schema: Joi.object({}).required().unknown(true),
-        transformer: Joi.string().optional(),
-    }));
-}
-function generateQueryPreviewValidation() {
-    // prettier-ignore
-    return joiValidator.body(Joi.object({
-        fields: Joi.object().required(),
-        queryVerb: Joi.string().allow().required(),
-        extra: Joi.object().optional(),
-        datasourceId: Joi.string().required(),
-        transformer: Joi.string().optional(),
-        parameters: Joi.object({}).required().unknown(true)
-    }));
-}
 router
     .get("/api/queries", authorized(BUILDER), queryController.fetch)
     .post("/api/queries", bodySubResource("datasourceId", "_id"), authorized(BUILDER), generateQueryValidation(), queryController.save)
+    .post("/api/queries/import", authorized(BUILDER), queryController.import)
     .post("/api/queries/preview", bodyResource("datasourceId"), authorized(BUILDER), generateQueryPreviewValidation(), queryController.preview)
     .get("/api/queries/:queryId", paramResource("queryId"), authorized(PermissionTypes.QUERY, PermissionLevels.READ), queryController.find)
     .post("/api/queries/:queryId", paramResource("queryId"), authorized(PermissionTypes.QUERY, PermissionLevels.WRITE), queryController.execute)

package/dist/api/routes/user.js

@@ -10,5 +10,7 @@ router
     .put("/api/users/metadata", authorized(PermissionTypes.USER, PermissionLevels.WRITE), controller.updateMetadata)
     .post("/api/users/metadata/self", authorized(PermissionTypes.USER, PermissionLevels.WRITE), controller.updateSelfMetadata)
     .delete("/api/users/metadata/:id", authorized(PermissionTypes.USER, PermissionLevels.WRITE), controller.destroyMetadata)
-    .post("/api/users/metadata/sync/:id", authorized(PermissionTypes.USER, PermissionLevels.WRITE), controller.syncUser);
+    .post("/api/users/metadata/sync/:id", authorized(PermissionTypes.USER, PermissionLevels.WRITE), controller.syncUser)
+    .post("/api/users/flags", authorized(PermissionTypes.USER, PermissionLevels.WRITE), controller.setFlag)
+    .get("/api/users/flags", authorized(PermissionTypes.USER, PermissionLevels.READ), controller.getFlags);
 module.exports = router;

package/dist/db/utils.js

@@ -28,6 +28,7 @@ const DocumentTypes = {
     DEPLOYMENTS: "deployments",
     METADATA: "metadata",
     MEM_VIEW: "view",
+    USER_FLAG: "flag",
 };
 const ViewNames = {
     LINK: "by_link",
@@ -271,6 +272,13 @@ exports.getQueryParams = (datasourceId = null, otherProps = {}) => {
     }
     return getDocParams(DocumentTypes.QUERY, `${datasourceId}${SEPARATOR}`, otherProps);
 };
+/**
+ * Generates a new flag document ID.
+ * @returns {string} The ID of the flag document that was generated.
+ */
+exports.generateUserFlagID = userId => {
+    return `${DocumentTypes.USER_FLAG}${SEPARATOR}${userId}`;
+};
 exports.generateMetadataID = (type, entityId) => {
     return `${DocumentTypes.METADATA}${SEPARATOR}${type}${SEPARATOR}${entityId}`;
 };

package/dist/integrations/rest.js

@@ -10,18 +10,50 @@ 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",
+    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 SCHEMA = {
         docs: "https://github.com/node-fetch/node-fetch",
-        description: "Representational state transfer (REST) is a de-facto standard for a software architecture for interactive applications that typically use multiple Web services. ",
+        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.",
         friendlyName: "REST API",
         datasource: {
             url: {
                 type: datasource_1.DatasourceFieldTypes.STRING,
-                default: "localhost",
-                required: true,
+                default: "",
+                required: false,
+                deprecated: true,
             },
             defaultHeaders: {
                 type: datasource_1.DatasourceFieldTypes.OBJECT,
@@ -34,169 +66,134 @@ var RestModule;
                 readable: true,
                 displayName: "POST",
                 type: datasource_1.QueryTypes.FIELDS,
-                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,
-                    },
-                },
+                fields: coreFields,
             },
             read: {
                 displayName: "GET",
                 readable: true,
                 type: datasource_1.QueryTypes.FIELDS,
-                urlDisplay: true,
-                fields: {
-                    path: {
-                        type: datasource_1.DatasourceFieldTypes.STRING,
-                    },
-                    queryString: {
-                        type: datasource_1.DatasourceFieldTypes.STRING,
-                    },
-                    headers: {
-                        type: datasource_1.DatasourceFieldTypes.OBJECT,
-                    },
-                },
+                fields: coreFields,
             },
             update: {
                 displayName: "PUT",
                 readable: true,
                 type: datasource_1.QueryTypes.FIELDS,
-                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,
-                    },
-                },
+                fields: coreFields,
             },
             patch: {
                 displayName: "PATCH",
                 readable: true,
                 type: datasource_1.QueryTypes.FIELDS,
-                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,
-                    },
-                },
+                fields: coreFields,
             },
             delete: {
                 displayName: "DELETE",
                 type: datasource_1.QueryTypes.FIELDS,
-                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,
-                    },
-                },
+                fields: coreFields,
             },
         },
     };
     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");
                 if (contentType && contentType.indexOf("application/json") !== -1) {
-                    return yield response.json();
+                    data = yield response.json();
+                    raw = JSON.stringify(data);
                 }
                 else {
-                    return yield response.text();
+                    data = yield response.text();
+                    raw = data;
                 }
+                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) {
-            return `${this.config.url}/${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;
         }
-        create({ path = "", queryString = "", headers = {}, json = {} }) {
+        _req(query) {
             return __awaiter(this, void 0, void 0, function* () {
+                const { path = "", queryString = "", headers = {}, method = "GET", disabledHeaders, bodyType, requestBody } = query;
                 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),
-                });
+                if (disabledHeaders) {
+                    for (let headerKey of Object.keys(this.headers)) {
+                        if (disabledHeaders[headerKey]) {
+                            delete this.headers[headerKey];
+                        }
+                    }
+                }
+                let json;
+                if (bodyType === BodyTypes.JSON && requestBody) {
+                    try {
+                        json = JSON.parse(requestBody);
+                    }
+                    catch (err) {
+                        throw "Invalid JSON for request body";
+                    }
+                }
+                const input = { method, headers: this.headers };
+                if (json && typeof json === "object" && Object.keys(json).length > 0) {
+                    input.body = JSON.stringify(json);
+                }
+                this.startTimeMs = performance.now();
+                const response = yield fetch(this.getUrl(path, queryString), input);
                 return yield this.parseResponse(response);
             });
         }
-        read({ path = "", queryString = "", headers = {} }) {
+        create(opts) {
             return __awaiter(this, void 0, void 0, function* () {
-                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);
+                return this._req(Object.assign(Object.assign({}, opts), { method: "POST" }));
             });
         }
-        update({ path = "", queryString = "", headers = {}, json = {} }) {
+        read(opts) {
             return __awaiter(this, void 0, void 0, function* () {
-                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);
+                return this._req(Object.assign(Object.assign({}, opts), { method: "GET" }));
             });
         }
-        patch({ path = "", queryString = "", headers = {}, json = {} }) {
+        update(opts) {
             return __awaiter(this, void 0, void 0, function* () {
-                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);
+                return this._req(Object.assign(Object.assign({}, opts), { method: "PUT" }));
             });
         }
-        delete({ path = "", queryString = "", headers = {} }) {
+        patch(opts) {
             return __awaiter(this, void 0, void 0, function* () {
-                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);
+                return this._req(Object.assign(Object.assign({}, opts), { method: "PATCH" }));
+            });
+        }
+        delete(opts) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return this._req(Object.assign(Object.assign({}, opts), { method: "DELETE" }));
             });
         }
     }

package/dist/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@budibase/server",
     "email": "hi@budibase.com",
-    "version": "1.0.16",
+    "version": "1.0.19-alpha.1",
     "description": "Budibase Web Server",
     "main": "src/index.ts",
     "repository": {
@@ -69,9 +69,10 @@
     "author": "Budibase",
     "license": "GPL-3.0",
     "dependencies": {
-        "@budibase/auth": "^1.0.16",
-        "@budibase/client": "^1.0.16",
-        "@budibase/string-templates": "^1.0.16",
+        "@apidevtools/swagger-parser": "^10.0.3",
+        "@budibase/auth": "^1.0.19-alpha.1",
+        "@budibase/client": "^1.0.19-alpha.1",
+        "@budibase/string-templates": "^1.0.19-alpha.1",
         "@bull-board/api": "^3.7.0",
         "@bull-board/koa": "^3.7.0",
         "@elastic/elasticsearch": "7.10.0",
@@ -85,12 +86,14 @@
         "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",
         "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",
@@ -146,6 +149,7 @@
         "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

@@ -24,6 +24,12 @@ 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];
@@ -31,7 +37,13 @@ function runAndTransform(datasource, queryVerb, query, transformer) {
             throw "Integration type does not exist.";
         }
         const integration = new Integration(datasource.config);
-        let rows = formatResponse(yield integration[queryVerb](query));
+        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;
+        }
         // transform as required
         if (transformer) {
             const runner = new ScriptRunner(transformer, { data: rows });
@@ -50,7 +62,7 @@ function runAndTransform(datasource, queryVerb, query, transformer) {
         if (integration.end) {
             integration.end();
         }
-        return { rows, keys };
+        return { rows, keys, info, extra };
     });
 }
 module.exports = (input, callback) => {