@budibase/server 1.0.21 → 1.0.23-alpha.2

package/dist/api/controllers/automation.js

@@ -12,10 +12,12 @@ const CouchDB = require("../../db");
 const actions = require("../../automations/actions");
 const triggers = require("../../automations/triggers");
 const { getAutomationParams, generateAutomationID } = require("../../db/utils");
-const { checkForWebhooks, updateTestHistory, } = require("../../automations/utils");
+const { checkForWebhooks, updateTestHistory, removeDeprecated, } = require("../../automations/utils");
 const { deleteEntityMetadata } = require("../../utilities");
 const { MetadataTypes } = require("../../constants");
 const { setTestFlag, clearTestFlag } = require("../../utilities/redis");
+const ACTION_DEFS = removeDeprecated(actions.ACTION_DEFINITIONS);
+const TRIGGER_DEFS = removeDeprecated(triggers.TRIGGER_DEFINITIONS);
 /*************************
  *                       *
  *   BUILDER FUNCTIONS   *
@@ -137,19 +139,19 @@ exports.destroy = function (ctx) {
 };
 exports.getActionList = function (ctx) {
     return __awaiter(this, void 0, void 0, function* () {
-        ctx.body = actions.ACTION_DEFINITIONS;
+        ctx.body = ACTION_DEFS;
     });
 };
 exports.getTriggerList = function (ctx) {
     return __awaiter(this, void 0, void 0, function* () {
-        ctx.body = triggers.TRIGGER_DEFINITIONS;
+        ctx.body = TRIGGER_DEFS;
     });
 };
 module.exports.getDefinitionList = function (ctx) {
     return __awaiter(this, void 0, void 0, function* () {
         ctx.body = {
-            trigger: triggers.TRIGGER_DEFINITIONS,
-            action: actions.ACTION_DEFINITIONS,
+            trigger: TRIGGER_DEFS,
+            action: ACTION_DEFS,
         };
     });
 };

package/dist/api/controllers/query/import/index.js

@@ -0,0 +1,79 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RestImporter = void 0;
+const db_1 = __importDefault(require("../../../../db"));
+const validation_1 = require("../validation");
+const utils_1 = require("../../../../db/utils");
+const openapi2_1 = require("./sources/openapi2");
+const curl_1 = require("./sources/curl");
+class RestImporter {
+    constructor(data) {
+        this.init = () => __awaiter(this, void 0, void 0, function* () {
+            for (let source of this.sources) {
+                if (yield source.isSupported(this.data)) {
+                    this.source = source;
+                    break;
+                }
+            }
+        });
+        this.getInfo = () => __awaiter(this, void 0, void 0, function* () {
+            return this.source.getInfo();
+        });
+        this.importQueries = (appId, datasourceId) => __awaiter(this, void 0, void 0, function* () {
+            // constuct the queries
+            let queries = yield this.source.getQueries(datasourceId);
+            // validate queries
+            const errorQueries = [];
+            const schema = validation_1.queryValidation();
+            queries = queries
+                .filter(query => {
+                const validation = schema.validate(query);
+                if (validation.error) {
+                    errorQueries.push(query);
+                    return false;
+                }
+                return true;
+            })
+                .map(query => {
+                query._id = utils_1.generateQueryID(query.datasourceId);
+                return query;
+            });
+            // persist queries
+            const db = new db_1.default(appId);
+            const response = yield db.bulkDocs(queries);
+            // create index to seperate queries and errors
+            const queryIndex = queries.reduce((acc, query) => {
+                if (query._id) {
+                    acc[query._id] = query;
+                }
+                return acc;
+            }, {});
+            // check for failed writes
+            response.forEach((query) => {
+                if (!query.ok) {
+                    errorQueries.push(queryIndex[query.id]);
+                    delete queryIndex[query.id];
+                }
+            });
+            return {
+                errorQueries,
+                queries: Object.values(queryIndex),
+            };
+        });
+        this.data = data;
+        this.sources = [new openapi2_1.OpenAPI2(), new curl_1.Curl()];
+    }
+}
+exports.RestImporter = RestImporter;

package/dist/api/controllers/query/import/sources/base/index.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportSource = void 0;
+var MethodToVerb;
+(function (MethodToVerb) {
+    MethodToVerb["get"] = "read";
+    MethodToVerb["post"] = "create";
+    MethodToVerb["put"] = "update";
+    MethodToVerb["patch"] = "patch";
+    MethodToVerb["delete"] = "delete";
+})(MethodToVerb || (MethodToVerb = {}));
+class ImportSource {
+    constructor() {
+        this.constructQuery = (datasourceId, name, method, path, queryString, headers = {}, parameters = [], body = undefined) => {
+            const readable = true;
+            const queryVerb = this.verbFromMethod(method);
+            const transformer = "return data";
+            const schema = {};
+            path = this.processPath(path);
+            queryString = this.processQuery(queryString);
+            const requestBody = JSON.stringify(body, null, 2);
+            const query = {
+                datasourceId,
+                name,
+                parameters,
+                fields: {
+                    headers,
+                    queryString,
+                    path,
+                    requestBody,
+                },
+                transformer,
+                schema,
+                readable,
+                queryVerb,
+            };
+            return query;
+        };
+        this.verbFromMethod = (method) => {
+            const verb = MethodToVerb[method];
+            if (!verb) {
+                throw new Error(`Unsupported method: ${method}`);
+            }
+            return verb;
+        };
+        this.processPath = (path) => {
+            if (path === null || path === void 0 ? void 0 : path.startsWith("/")) {
+                path = path.substring(1);
+            }
+            // add extra braces around params for binding
+            path = path.replace(/[{]/g, "{{");
+            path = path.replace(/[}]/g, "}}");
+            return path;
+        };
+        this.processQuery = (queryString) => {
+            if (queryString === null || queryString === void 0 ? void 0 : queryString.startsWith("?")) {
+                return queryString.substring(1);
+            }
+            return queryString;
+        };
+    }
+}
+exports.ImportSource = ImportSource;

package/dist/api/controllers/query/import/sources/base/openapi.js

@@ -0,0 +1,42 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAPISource = void 0;
+const _1 = require(".");
+const swagger_parser_1 = __importDefault(require("@apidevtools/swagger-parser"));
+const yaml = require("js-yaml");
+class OpenAPISource extends _1.ImportSource {
+    constructor() {
+        super(...arguments);
+        this.parseData = (data) => __awaiter(this, void 0, void 0, function* () {
+            let json;
+            try {
+                json = JSON.parse(data);
+            }
+            catch (jsonErr) {
+                // couldn't parse json
+                // try to convert yaml -> json
+                try {
+                    json = yaml.load(data);
+                }
+                catch (yamlErr) {
+                    // couldn't parse yaml
+                    throw new Error("Could not parse JSON or YAML");
+                }
+            }
+            return swagger_parser_1.default.validate(json, {});
+        });
+    }
+}
+exports.OpenAPISource = OpenAPISource;

package/dist/api/controllers/query/import/sources/curl.js

@@ -0,0 +1,90 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Curl = void 0;
+const base_1 = require("./base");
+const url_1 = require("url");
+const curlconverter = require("curlconverter");
+const parseCurl = (data) => {
+    const curlJson = curlconverter.toJsonString(data);
+    return JSON.parse(curlJson);
+};
+/**
+ * The curl converter parses the request body into the key field of an object
+ * e.g. --d '{"key":"val"}' produces an object { "{"key":"val"}" : "" }
+ * This is not what we want, so we need to parse out the key from the object
+ */
+const parseBody = (curl) => {
+    if (curl.data) {
+        const keys = Object.keys(curl.data);
+        if (keys.length) {
+            const key = keys[0];
+            try {
+                return JSON.parse(key);
+            }
+            catch (e) {
+                // do nothing
+            }
+        }
+    }
+    return undefined;
+};
+const parseCookie = (curl) => {
+    if (curl.cookies) {
+        return Object.entries(curl.cookies).reduce((acc, entry) => {
+            const [key, value] = entry;
+            return acc + `${key}=${value}; `;
+        }, "");
+    }
+    return null;
+};
+/**
+ * Curl
+ * https://curl.se/docs/manpage.html
+ */
+class Curl extends base_1.ImportSource {
+    constructor() {
+        super(...arguments);
+        this.isSupported = (data) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const curl = parseCurl(data);
+                this.curl = curl;
+            }
+            catch (err) {
+                return false;
+            }
+            return true;
+        });
+        this.getInfo = () => __awaiter(this, void 0, void 0, function* () {
+            const url = new url_1.URL(this.curl.url);
+            return {
+                url: url.origin,
+                name: url.hostname,
+            };
+        });
+        this.getQueries = (datasourceId) => __awaiter(this, void 0, void 0, function* () {
+            const url = new url_1.URL(this.curl.raw_url);
+            const name = url.pathname;
+            const path = url.pathname;
+            const method = this.curl.method;
+            const queryString = url.search;
+            const headers = this.curl.headers;
+            const requestBody = parseBody(this.curl);
+            const cookieHeader = parseCookie(this.curl);
+            if (cookieHeader) {
+                headers["Cookie"] = cookieHeader;
+            }
+            const query = this.constructQuery(datasourceId, name, method, path, queryString, headers, [], requestBody);
+            return [query];
+        });
+    }
+}
+exports.Curl = Curl;

package/dist/api/controllers/query/import/sources/openapi2.js

@@ -0,0 +1,139 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAPI2 = void 0;
+const openapi_types_1 = require("openapi-types");
+const openapi_1 = require("./base/openapi");
+const parameterNotRef = (param) => {
+    // all refs are deferenced by parser library
+    return true;
+};
+const isOpenAPI2 = (document) => {
+    if (document.swagger === "2.0") {
+        return true;
+    }
+    else {
+        return false;
+    }
+};
+const methods = Object.values(openapi_types_1.OpenAPIV2.HttpMethods);
+const isOperation = (key, pathItem) => {
+    return methods.includes(key);
+};
+const isParameter = (key, pathItem) => {
+    return !isOperation(key, pathItem);
+};
+/**
+ * OpenAPI Version 2.0 - aka "Swagger"
+ * https://github.com/OAI/OpenAPI-Specification/blob/main/versions/2.0.md
+ */
+class OpenAPI2 extends openapi_1.OpenAPISource {
+    constructor() {
+        super(...arguments);
+        this.isSupported = (data) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const document = yield this.parseData(data);
+                if (isOpenAPI2(document)) {
+                    this.document = document;
+                    return true;
+                }
+                else {
+                    return false;
+                }
+            }
+            catch (err) {
+                return false;
+            }
+        });
+        this.getInfo = () => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const scheme = ((_a = this.document.schemes) === null || _a === void 0 ? void 0 : _a.includes("https")) ? "https" : "http";
+            const basePath = this.document.basePath || "";
+            const host = this.document.host || "<host>";
+            const url = `${scheme}://${host}${basePath}`;
+            const name = this.document.info.title || "Swagger Import";
+            return {
+                url: url,
+                name: name,
+            };
+        });
+        this.getQueries = (datasourceId) => __awaiter(this, void 0, void 0, function* () {
+            const queries = [];
+            for (let [path, pathItem] of Object.entries(this.document.paths)) {
+                // parameters that apply to every operation in the path
+                let pathParams = [];
+                for (let [key, opOrParams] of Object.entries(pathItem)) {
+                    if (isParameter(key, opOrParams)) {
+                        const pathParameters = opOrParams;
+                        pathParams.push(...pathParameters);
+                        continue;
+                    }
+                    // can not be a parameter, must be an operation
+                    const operation = opOrParams;
+                    const methodName = key;
+                    const name = operation.operationId || path;
+                    let queryString = "";
+                    const headers = {};
+                    let requestBody = undefined;
+                    const parameters = [];
+                    if (operation.consumes) {
+                        headers["Content-Type"] = operation.consumes[0];
+                    }
+                    // combine the path parameters with the operation parameters
+                    const operationParams = operation.parameters || [];
+                    const allParams = [...pathParams, ...operationParams];
+                    for (let param of allParams) {
+                        if (parameterNotRef(param)) {
+                            switch (param.in) {
+                                case "query":
+                                    let prefix = "";
+                                    if (queryString) {
+                                        prefix = "&";
+                                    }
+                                    queryString = `${queryString}${prefix}${param.name}={{${param.name}}}`;
+                                    break;
+                                case "header":
+                                    headers[param.name] = `{{${param.name}}}`;
+                                    break;
+                                case "path":
+                                    // do nothing: param is already in the path
+                                    break;
+                                case "formData":
+                                    // future enhancement
+                                    break;
+                                case "body":
+                                    // set the request body to the example provided
+                                    // future enhancement: generate an example from the schema
+                                    let bodyParam = param;
+                                    if (param.schema.example) {
+                                        const schema = bodyParam.schema;
+                                        requestBody = schema.example;
+                                    }
+                                    break;
+                            }
+                            // add the parameter if it can be bound in our config
+                            if (["query", "header", "path"].includes(param.in)) {
+                                parameters.push({
+                                    name: param.name,
+                                    default: param.default || "",
+                                });
+                            }
+                        }
+                    }
+                    const query = this.constructQuery(datasourceId, name, methodName, path, queryString, headers, parameters, requestBody);
+                    queries.push(query);
+                }
+            }
+            return queries;
+        });
+    }
+}
+exports.OpenAPI2 = OpenAPI2;