@budibase/server 2.6.19-alpha.4 → 2.6.19-alpha.40

package/dist/integrations/rest.js

@@ -1,400 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-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 });
-const types_1 = require("@budibase/types");
-const lodash_1 = require("lodash");
-const https = __importStar(require("https"));
-const querystring_1 = __importDefault(require("querystring"));
-const node_fetch_1 = __importDefault(require("node-fetch"));
-const utilities_1 = require("../utilities");
-const perf_hooks_1 = require("perf_hooks");
-const form_data_1 = __importDefault(require("form-data"));
-const url_1 = require("url");
-const backend_core_1 = require("@budibase/backend-core");
-const BodyTypes = {
-    NONE: "none",
-    FORM_DATA: "form",
-    XML: "xml",
-    ENCODED: "encoded",
-    JSON: "json",
-    TEXT: "text",
-};
-const coreFields = {
-    path: {
-        type: types_1.DatasourceFieldType.STRING,
-        display: "URL",
-    },
-    queryString: {
-        type: types_1.DatasourceFieldType.STRING,
-    },
-    headers: {
-        type: types_1.DatasourceFieldType.OBJECT,
-    },
-    enabledHeaders: {
-        type: types_1.DatasourceFieldType.OBJECT,
-    },
-    requestBody: {
-        type: types_1.DatasourceFieldType.JSON,
-    },
-    bodyType: {
-        type: types_1.DatasourceFieldType.STRING,
-        enum: Object.values(BodyTypes),
-    },
-    pagination: {
-        type: types_1.DatasourceFieldType.OBJECT,
-    },
-};
-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.",
-    friendlyName: "REST API",
-    type: "API",
-    datasource: {
-        url: {
-            type: types_1.DatasourceFieldType.STRING,
-            default: "",
-            required: false,
-            deprecated: true,
-        },
-        defaultHeaders: {
-            type: types_1.DatasourceFieldType.OBJECT,
-            required: false,
-            default: {},
-        },
-        rejectUnauthorized: {
-            display: "Reject Unauthorized",
-            type: types_1.DatasourceFieldType.BOOLEAN,
-            default: true,
-            required: false,
-        },
-    },
-    query: {
-        create: {
-            readable: true,
-            displayName: "POST",
-            type: types_1.QueryType.FIELDS,
-            fields: coreFields,
-        },
-        read: {
-            displayName: "GET",
-            readable: true,
-            type: types_1.QueryType.FIELDS,
-            fields: coreFields,
-        },
-        update: {
-            displayName: "PUT",
-            readable: true,
-            type: types_1.QueryType.FIELDS,
-            fields: coreFields,
-        },
-        patch: {
-            displayName: "PATCH",
-            readable: true,
-            type: types_1.QueryType.FIELDS,
-            fields: coreFields,
-        },
-        delete: {
-            displayName: "DELETE",
-            type: types_1.QueryType.FIELDS,
-            fields: coreFields,
-        },
-    },
-};
-class RestIntegration {
-    constructor(config) {
-        this.headers = {};
-        this.startTimeMs = perf_hooks_1.performance.now();
-        this.config = config;
-    }
-    parseResponse(response, pagination) {
-        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 if (contentType.includes("application/pdf")) {
-                    data = yield response.arrayBuffer(); // Save PDF as ArrayBuffer
-                    raw = Buffer.from(data);
-                }
-                else {
-                    data = yield response.text();
-                    raw = data;
-                }
-            }
-            catch (err) {
-                throw "Failed to parse response body.";
-            }
-            const size = (0, utilities_1.formatBytes)(response.headers.get("content-length") || Buffer.byteLength(raw, "utf8"));
-            const time = `${Math.round(perf_hooks_1.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;
-            }
-            // Check if a pagination cursor exists in the response
-            let nextCursor = null;
-            if (pagination === null || pagination === void 0 ? void 0 : pagination.responseParam) {
-                nextCursor = (0, lodash_1.get)(data, pagination.responseParam);
-            }
-            return {
-                data,
-                info: {
-                    code: response.status,
-                    size,
-                    time,
-                },
-                extra: {
-                    raw,
-                    headers,
-                },
-                pagination: {
-                    cursor: nextCursor,
-                },
-            };
-        });
-    }
-    getUrl(path, queryString, pagination, paginationValues) {
-        // Add pagination params to query string if required
-        if ((pagination === null || pagination === void 0 ? void 0 : pagination.location) === "query" && paginationValues) {
-            const { pageParam, sizeParam } = pagination;
-            const params = new url_1.URLSearchParams();
-            // Append page number or cursor param if configured
-            if (pageParam && paginationValues.page != null) {
-                params.append(pageParam, paginationValues.page);
-            }
-            // Append page size param if configured
-            if (sizeParam && paginationValues.limit != null) {
-                params.append(sizeParam, String(paginationValues.limit));
-            }
-            // Prepend query string with pagination params
-            let paginationString = params.toString();
-            if (paginationString) {
-                queryString = `${paginationString}&${queryString}`;
-            }
-        }
-        if (queryString) {
-            // make sure the query string is fully encoded
-            queryString = "?" + querystring_1.default.encode(querystring_1.default.decode(queryString));
-        }
-        const main = `${path}${queryString}`;
-        let complete = main;
-        if (this.config.url && !main.startsWith("http")) {
-            complete = !this.config.url ? main : `${this.config.url}/${main}`;
-        }
-        if (!complete.startsWith("http")) {
-            complete = `http://${complete}`;
-        }
-        return complete;
-    }
-    addBody(bodyType, body, input, pagination, paginationValues) {
-        if (!input.headers) {
-            input.headers = {};
-        }
-        if (bodyType === BodyTypes.NONE) {
-            return input;
-        }
-        let error, object = {}, string = "";
-        try {
-            if (body) {
-                string = typeof body !== "string" ? JSON.stringify(body) : body;
-                object = typeof body === "object" ? body : JSON.parse(body);
-            }
-        }
-        catch (err) {
-            error = err;
-        }
-        // Util to add pagination values to a certain body type
-        const addPaginationToBody = (insertFn) => {
-            if ((pagination === null || pagination === void 0 ? void 0 : pagination.location) === "body") {
-                if ((pagination === null || pagination === void 0 ? void 0 : pagination.pageParam) && (paginationValues === null || paginationValues === void 0 ? void 0 : paginationValues.page) != null) {
-                    insertFn(pagination.pageParam, paginationValues.page);
-                }
-                if ((pagination === null || pagination === void 0 ? void 0 : pagination.sizeParam) && (paginationValues === null || paginationValues === void 0 ? void 0 : paginationValues.limit) != null) {
-                    insertFn(pagination.sizeParam, paginationValues.limit);
-                }
-            }
-        };
-        switch (bodyType) {
-            case BodyTypes.TEXT:
-                // content type defaults to plaintext
-                input.body = string;
-                break;
-            case BodyTypes.ENCODED:
-                const params = new url_1.URLSearchParams();
-                for (let [key, value] of Object.entries(object)) {
-                    params.append(key, value);
-                }
-                addPaginationToBody((key, value) => {
-                    params.append(key, value);
-                });
-                input.body = params;
-                break;
-            case BodyTypes.FORM_DATA:
-                const form = new form_data_1.default();
-                for (let [key, value] of Object.entries(object)) {
-                    form.append(key, value);
-                }
-                addPaginationToBody((key, value) => {
-                    form.append(key, value);
-                });
-                input.body = form;
-                break;
-            case BodyTypes.XML:
-                if (object != null && Object.keys(object).length) {
-                    string = new XmlBuilder().buildObject(object);
-                }
-                input.body = string;
-                input.headers["Content-Type"] = "application/xml";
-                break;
-            case BodyTypes.JSON:
-                // if JSON error, throw it
-                if (error) {
-                    throw "Invalid JSON for request body";
-                }
-                addPaginationToBody((key, value) => {
-                    object[key] = value;
-                });
-                input.body = JSON.stringify(object);
-                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 types_1.RestAuthType.BASIC:
-                        config = authConfig.config;
-                        headers.Authorization = `Basic ${Buffer.from(`${config.username}:${config.password}`).toString("base64")}`;
-                        break;
-                    case types_1.RestAuthType.BEARER:
-                        config = authConfig.config;
-                        headers.Authorization = `Bearer ${config.token}`;
-                        break;
-                }
-            }
-        }
-        return headers;
-    }
-    _req(query) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { path = "", queryString = "", headers = {}, method = "GET", disabledHeaders, bodyType, requestBody, authConfigId, pagination, paginationValues, } = 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 };
-            input = this.addBody(bodyType, requestBody, input, pagination, paginationValues);
-            if (this.config.rejectUnauthorized == false) {
-                input.agent = new https.Agent({
-                    rejectUnauthorized: false,
-                });
-            }
-            // Deprecated by rejectUnauthorized
-            if (this.config.legacyHttpParser) {
-                // https://github.com/nodejs/node/issues/43798
-                input.extraHttpOptions = { insecureHTTPParser: true };
-            }
-            this.startTimeMs = perf_hooks_1.performance.now();
-            const url = this.getUrl(path, queryString, pagination, paginationValues);
-            if (yield backend_core_1.blacklist.isBlacklisted(url)) {
-                throw new Error("Cannot connect to URL.");
-            }
-            const response = yield (0, node_fetch_1.default)(url, input);
-            return yield this.parseResponse(response, pagination);
-        });
-    }
-    create(opts) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this._req(Object.assign(Object.assign({}, opts), { method: "POST" }));
-        });
-    }
-    read(opts) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this._req(Object.assign(Object.assign({}, opts), { method: "GET" }));
-        });
-    }
-    update(opts) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this._req(Object.assign(Object.assign({}, opts), { method: "PUT" }));
-        });
-    }
-    patch(opts) {
-        return __awaiter(this, void 0, void 0, function* () {
-            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" }));
-        });
-    }
-}
-exports.default = {
-    schema: SCHEMA,
-    integration: RestIntegration,
-};

package/dist/integrations/s3.js

@@ -1,256 +0,0 @@
-"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 });
-const types_1 = require("@budibase/types");
-const aws_sdk_1 = __importDefault(require("aws-sdk"));
-const csvtojson_1 = __importDefault(require("csvtojson"));
-const SCHEMA = {
-    docs: "https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/S3.html",
-    description: "Amazon Simple Storage Service (Amazon S3) is an object storage service that offers industry-leading scalability, data availability, security, and performance.",
-    friendlyName: "Amazon S3",
-    type: "Object store",
-    features: [types_1.DatasourceFeature.CONNECTION_CHECKING],
-    datasource: {
-        region: {
-            type: "string",
-            required: false,
-            default: "us-east-1",
-        },
-        accessKeyId: {
-            type: "password",
-            required: true,
-        },
-        secretAccessKey: {
-            type: "password",
-            required: true,
-        },
-        endpoint: {
-            type: "string",
-            required: false,
-        },
-        signatureVersion: {
-            type: "string",
-            required: false,
-            default: "v4",
-        },
-    },
-    query: {
-        create: {
-            type: types_1.QueryType.FIELDS,
-            fields: {
-                bucket: {
-                    display: "New Bucket",
-                    type: types_1.DatasourceFieldType.STRING,
-                    required: true,
-                },
-                location: {
-                    required: true,
-                    default: "us-east-1",
-                    type: types_1.DatasourceFieldType.STRING,
-                },
-                grantFullControl: {
-                    display: "Grant full control",
-                    type: types_1.DatasourceFieldType.STRING,
-                },
-                grantRead: {
-                    display: "Grant read",
-                    type: types_1.DatasourceFieldType.STRING,
-                },
-                grantReadAcp: {
-                    display: "Grant read ACP",
-                    type: types_1.DatasourceFieldType.STRING,
-                },
-                grantWrite: {
-                    display: "Grant write",
-                    type: types_1.DatasourceFieldType.STRING,
-                },
-                grantWriteAcp: {
-                    display: "Grant write ACP",
-                    type: types_1.DatasourceFieldType.STRING,
-                },
-            },
-        },
-        read: {
-            type: types_1.QueryType.FIELDS,
-            fields: {
-                bucket: {
-                    type: types_1.DatasourceFieldType.STRING,
-                    required: true,
-                },
-                delimiter: {
-                    type: types_1.DatasourceFieldType.STRING,
-                },
-                marker: {
-                    type: types_1.DatasourceFieldType.STRING,
-                },
-                maxKeys: {
-                    type: types_1.DatasourceFieldType.NUMBER,
-                    display: "Max Keys",
-                },
-                prefix: {
-                    type: types_1.DatasourceFieldType.STRING,
-                },
-            },
-        },
-        readCsv: {
-            displayName: "Read CSV",
-            type: types_1.QueryType.FIELDS,
-            readable: true,
-            fields: {
-                bucket: {
-                    type: types_1.DatasourceFieldType.STRING,
-                    required: true,
-                },
-                key: {
-                    type: types_1.DatasourceFieldType.STRING,
-                    required: true,
-                },
-            },
-        },
-        delete: {
-            type: types_1.QueryType.FIELDS,
-            fields: {
-                bucket: {
-                    type: types_1.DatasourceFieldType.STRING,
-                    required: true,
-                },
-                delete: {
-                    type: types_1.DatasourceFieldType.JSON,
-                    required: true,
-                },
-            },
-        },
-    },
-    extra: {
-        acl: {
-            required: false,
-            displayName: "ACL",
-            type: types_1.DatasourceFieldType.LIST,
-            data: {
-                create: [
-                    "private",
-                    "public-read",
-                    "public-read-write",
-                    "authenticated-read",
-                ],
-            },
-        },
-    },
-};
-class S3Integration {
-    constructor(config) {
-        this.config = config;
-        if (this.config.endpoint) {
-            this.config.s3ForcePathStyle = true;
-        }
-        else {
-            delete this.config.endpoint;
-        }
-        this.client = new aws_sdk_1.default.S3(this.config);
-    }
-    testConnection() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const response = {
-                connected: false,
-            };
-            try {
-                yield this.client.listBuckets().promise();
-                response.connected = true;
-            }
-            catch (e) {
-                response.error = e.message;
-            }
-            return response;
-        });
-    }
-    create(query) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            let params = {
-                Bucket: query.bucket,
-                ACL: (_a = query.extra) === null || _a === void 0 ? void 0 : _a.acl,
-                GrantFullControl: query.grantFullControl,
-                GrantRead: query.grantRead,
-                GrantReadACP: query.grantReadAcp,
-                GrantWrite: query.grantWrite,
-                GrantWriteACP: query.grantWriteAcp,
-            };
-            if (query.location) {
-                params["CreateBucketConfiguration"] = {
-                    LocationConstraint: query.location,
-                };
-            }
-            return yield this.client.createBucket(params).promise();
-        });
-    }
-    read(query) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const response = yield this.client
-                .listObjects({
-                Bucket: query.bucket,
-                Delimiter: query.delimiter,
-                Marker: query.marker,
-                MaxKeys: query.maxKeys,
-                Prefix: query.prefix,
-            })
-                .promise();
-            return response.Contents;
-        });
-    }
-    readCsv(query) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const stream = this.client
-                .getObject({
-                Bucket: query.bucket,
-                Key: query.key,
-            })
-                .createReadStream();
-            let csvError = false;
-            return new Promise((resolve, reject) => {
-                stream.on("error", (err) => {
-                    reject(err);
-                });
-                const response = (0, csvtojson_1.default)()
-                    .fromStream(stream)
-                    .on("error", () => {
-                    csvError = true;
-                });
-                stream.on("finish", () => {
-                    resolve(response);
-                });
-            }).catch(err => {
-                if (csvError) {
-                    throw new Error("Could not read CSV");
-                }
-                else {
-                    throw err;
-                }
-            });
-        });
-    }
-    delete(query) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this.client
-                .deleteObjects({
-                Bucket: query.bucket,
-                Delete: JSON.parse(query.delete),
-            })
-                .promise();
-        });
-    }
-}
-exports.default = {
-    schema: SCHEMA,
-    integration: S3Integration,
-};