@budibase/server 2.1.45 → 2.1.46-alpha.0

package/dist/events/AutomationEmitter.js

@@ -1,10 +1,13 @@
 "use strict";
-const { rowEmission, tableEmission } = require("./utils");
-const mainEmitter = require("./index");
-const env = require("../environment");
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const utils_1 = require("./utils");
+const index_1 = __importDefault(require("./index"));
+const environment_1 = __importDefault(require("../environment"));
 // max number of automations that can chain on top of each other
 // TODO: in future make this configurable at the automation level
-const MAX_AUTOMATION_CHAIN = env.SELF_HOSTED ? 5 : 0;
+const MAX_AUTOMATION_CHAIN = environment_1.default.SELF_HOSTED ? 5 : 0;
 /**
  * Special emitter which takes the count of automation runs which have occurred and blocks an
  * automation from running if it has reached the maximum number of chained automations runs.
@@ -18,13 +21,13 @@ class AutomationEmitter {
             automationChainCount: chainCount,
         };
     }
-    emitRow(eventName, appId, row, table = null) {
+    emitRow(eventName, appId, row, table) {
         // don't emit even if we've reached max automation chain
         if (this.chainCount >= MAX_AUTOMATION_CHAIN) {
             return;
         }
-        rowEmission({
-            emitter: mainEmitter,
+        (0, utils_1.rowEmission)({
+            emitter: index_1.default,
             eventName,
             appId,
             row,
@@ -32,13 +35,13 @@ class AutomationEmitter {
             metadata: this.metadata,
         });
     }
-    emitTable(eventName, appId, table = null) {
+    emitTable(eventName, appId, table) {
         // don't emit even if we've reached max automation chain
         if (this.chainCount > MAX_AUTOMATION_CHAIN) {
             return;
         }
-        tableEmission({
-            emitter: mainEmitter,
+        (0, utils_1.tableEmission)({
+            emitter: index_1.default,
             eventName,
             appId,
             table,

package/dist/events/BudibaseEmitter.js

@@ -0,0 +1,24 @@
+"use strict";
+const events_1 = require("events");
+const utils_1 = require("./utils");
+/**
+ * keeping event emitter in one central location as it might be used for things other than
+ * automations (what it was for originally) - having a central emitter will be useful in the
+ * future.
+ */
+/**
+ * Extending the standard emitter to some syntactic sugar and standardisation to the emitted event.
+ * This is specifically quite important for template strings used in automations.
+ */
+class BudibaseEmitter extends events_1.EventEmitter {
+    emitRow(eventName, appId, row, table) {
+        (0, utils_1.rowEmission)({ emitter: this, eventName, appId, row, table });
+    }
+    emitTable(eventName, appId, table) {
+        (0, utils_1.tableEmission)({ emitter: this, eventName, appId, table });
+    }
+    emitPort(portNumber) {
+        this.emit("internal:port", portNumber);
+    }
+}
+module.exports = BudibaseEmitter;

package/dist/events/index.js

@@ -1,25 +1,7 @@
 "use strict";
-const EventEmitter = require("events").EventEmitter;
-const { rowEmission, tableEmission } = require("./utils");
-/**
- * keeping event emitter in one central location as it might be used for things other than
- * automations (what it was for originally) - having a central emitter will be useful in the
- * future.
- */
-/**
- * Extending the standard emitter to some syntactic sugar and standardisation to the emitted event.
- * This is specifically quite important for template strings used in automations.
- */
-class BudibaseEmitter extends EventEmitter {
-    emitRow(eventName, appId, row, table = null) {
-        rowEmission({ emitter: this, eventName, appId, row, table });
-    }
-    emitTable(eventName, appId, table = null) {
-        tableEmission({ emitter: this, eventName, appId, table });
-    }
-    emitPort(portNumber) {
-        this.emit("internal:port", portNumber);
-    }
-}
-const emitter = new BudibaseEmitter();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const BudibaseEmitter_1 = __importDefault(require("./BudibaseEmitter"));
+const emitter = new BudibaseEmitter_1.default();
 module.exports = emitter;

package/dist/events/utils.js

@@ -1,35 +1,43 @@
 "use strict";
-exports.rowEmission = ({ emitter, eventName, appId, row, table, metadata }) => {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tableEmission = exports.rowEmission = void 0;
+function rowEmission({ emitter, eventName, appId, row, table, metadata, }) {
     let event = {
         row,
         appId,
-        tableId: row.tableId,
+        tableId: row === null || row === void 0 ? void 0 : row.tableId,
     };
     if (table) {
         event.table = table;
     }
-    event.id = row._id;
-    if (row._rev) {
+    event.id = row === null || row === void 0 ? void 0 : row._id;
+    if (row === null || row === void 0 ? void 0 : row._rev) {
         event.revision = row._rev;
     }
     if (metadata) {
         event.metadata = metadata;
     }
     emitter.emit(eventName, event);
-};
-exports.tableEmission = ({ emitter, eventName, appId, table, metadata }) => {
-    const tableId = table._id;
+}
+exports.rowEmission = rowEmission;
+function tableEmission({ emitter, eventName, appId, table, metadata, }) {
+    const tableId = table === null || table === void 0 ? void 0 : table._id;
+    const inputTable = table;
+    if (inputTable) {
+        inputTable.tableId = tableId;
+    }
     let event = {
-        table: Object.assign(Object.assign({}, table), { tableId: tableId }),
+        table: inputTable,
         appId,
         tableId: tableId,
     };
     event.id = tableId;
-    if (table._rev) {
+    if (table === null || table === void 0 ? void 0 : table._rev) {
         event.revision = table._rev;
     }
     if (metadata) {
         event.metadata = metadata;
     }
     emitter.emit(eventName, event);
-};
+}
+exports.tableEmission = tableEmission;

package/dist/integrations/base/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/integrations/elasticsearch.js

@@ -10,7 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const types_1 = require("@budibase/types");
-const { Client } = require("@elastic/elasticsearch");
+const elasticsearch_1 = require("@elastic/elasticsearch");
 const SCHEMA = {
     docs: "https://www.elastic.co/guide/en/elasticsearch/client/javascript-api/current/index.html",
     description: "Elasticsearch is a search engine based on the Lucene library. It provides a distributed, multitenant-capable full-text search engine with an HTTP web interface and schema-free JSON documents.",
@@ -22,6 +22,21 @@ const SCHEMA = {
             required: true,
             default: "http://localhost:9200",
         },
+        ssl: {
+            type: types_1.DatasourceFieldType.BOOLEAN,
+            default: false,
+            required: false,
+        },
+        rejectUnauthorized: {
+            type: types_1.DatasourceFieldType.BOOLEAN,
+            default: true,
+            required: false,
+        },
+        ca: {
+            type: types_1.DatasourceFieldType.LONGFORM,
+            default: false,
+            required: false,
+        },
     },
     query: {
         create: {
@@ -76,7 +91,16 @@ const SCHEMA = {
 class ElasticSearchIntegration {
     constructor(config) {
         this.config = config;
-        this.client = new Client({ node: config.url });
+        const clientConfig = {
+            node: this.config.url,
+        };
+        if (this.config.ssl) {
+            clientConfig.ssl = {
+                rejectUnauthorized: this.config.rejectUnauthorized,
+                ca: this.config.ca || undefined,
+            };
+        }
+        this.client = new elasticsearch_1.Client(clientConfig);
     }
     create(query) {
         return __awaiter(this, void 0, void 0, function* () {

package/dist/integrations/googlesheets.js

@@ -18,9 +18,7 @@ const utils_1 = require("./utils");
 const constants_1 = require("../constants");
 const google_spreadsheet_1 = require("google-spreadsheet");
 const environment_1 = __importDefault(require("../environment"));
-const { getGlobalDB } = require("@budibase/backend-core/tenancy");
-const { getScopedConfig } = require("@budibase/backend-core/db");
-const { Configs } = require("@budibase/backend-core/constants");
+const backend_core_1 = require("@budibase/backend-core");
 const fetch = require("node-fetch");
 const SCHEMA = {
     plus: true,
@@ -140,9 +138,9 @@ class GoogleSheetsIntegration {
         return __awaiter(this, void 0, void 0, function* () {
             try {
                 // Initialise oAuth client
-                const db = getGlobalDB();
-                let googleConfig = yield getScopedConfig(db, {
-                    type: Configs.GOOGLE,
+                const db = backend_core_1.tenancy.getGlobalDB();
+                let googleConfig = yield backend_core_1.db.getScopedConfig(db, {
+                    type: backend_core_1.constants.Config.GOOGLE,
                 });
                 if (!googleConfig) {
                     googleConfig = {
@@ -227,6 +225,7 @@ class GoogleSheetsIntegration {
                 [constants_1.DataSourceOperation.UPDATE_TABLE]: () => this.updateTable(json.table),
                 [constants_1.DataSourceOperation.DELETE_TABLE]: () => { var _a; return this.deleteTable((_a = json === null || json === void 0 ? void 0 : json.table) === null || _a === void 0 ? void 0 : _a.name); },
             };
+            // @ts-ignore
             const internalQueryMethod = handlers[json.endpoint.operation];
             return yield internalQueryMethod();
         });

package/dist/integrations/index.js

@@ -12,6 +12,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getIntegration = exports.getDefinitions = void 0;
 const postgres_1 = __importDefault(require("./postgres"));
 const dynamodb_1 = __importDefault(require("./dynamodb"));
 const mongodb_1 = __importDefault(require("./mongodb"));
@@ -75,8 +76,8 @@ if (process.arch &&
     DEFINITIONS[types_1.SourceName.ORACLE] = oracle_1.default.schema;
     INTEGRATIONS[types_1.SourceName.ORACLE] = oracle_1.default.integration;
 }
-module.exports = {
-    getDefinitions: () => __awaiter(void 0, void 0, void 0, function* () {
+function getDefinitions() {
+    return __awaiter(this, void 0, void 0, function* () {
         const pluginSchemas = {};
         if (environment.SELF_HOSTED) {
             const plugins = yield (0, plugin_1.getPlugins)(types_1.PluginType.DATASOURCE);
@@ -90,9 +91,12 @@ module.exports = {
             }
         }
         return Object.assign(Object.assign({}, cloneDeep(DEFINITIONS)), pluginSchemas);
-    }),
-    getIntegration: (integration) => __awaiter(void 0, void 0, void 0, function* () {
-        var _a;
+    });
+}
+exports.getDefinitions = getDefinitions;
+function getIntegration(integration) {
+    var _a;
+    return __awaiter(this, void 0, void 0, function* () {
         if (INTEGRATIONS[integration]) {
             return INTEGRATIONS[integration];
         }
@@ -112,5 +116,10 @@ module.exports = {
             }
         }
         throw new Error("No datasource implementation found.");
-    }),
+    });
+}
+exports.getIntegration = getIntegration;
+exports.default = {
+    getDefinitions,
+    getIntegration,
 };

package/dist/integrations/microsoftSqlServer.js

@@ -195,15 +195,20 @@ class SqlServerIntegration extends sql_1.default {
                     .filter((constraint) => constraint.CONSTRAINT_TYPE === "PRIMARY KEY")
                     .map((constraint) => constraint.COLUMN_NAME);
                 const autoColumns = columns
-                    .filter((col) => col.IS_COMPUTED || col.IS_IDENTITY)
-                    .map((col) => col.COLUMN_NAME);
+                    .filter(col => col.IS_COMPUTED || col.IS_IDENTITY)
+                    .map(col => col.COLUMN_NAME);
+                const requiredColumns = columns
+                    .filter(col => col.IS_NULLABLE === "NO")
+                    .map(col => col.COLUMN_NAME);
                 let schema = {};
                 for (let def of definition) {
                     const name = def.COLUMN_NAME;
                     if (typeof name !== "string") {
                         continue;
                     }
-                    schema[name] = Object.assign(Object.assign({ autocolumn: !!autoColumns.find((col) => col === name), name: name }, (0, utils_1.convertSqlType)(def.DATA_TYPE)), { externalType: def.DATA_TYPE });
+                    schema[name] = Object.assign(Object.assign({ autocolumn: !!autoColumns.find(col => col === name), name: name, constraints: {
+                            presence: requiredColumns.find(col => col === name),
+                        } }, (0, utils_1.convertSqlType)(def.DATA_TYPE)), { externalType: def.DATA_TYPE });
                 }
                 tables[tableName] = {
                     _id: (0, utils_1.buildExternalTableId)(datasourceId, tableName),

package/dist/integrations/oracle.js

@@ -247,7 +247,9 @@ class OracleIntegration extends sql_1.default {
                     const columnName = oracleColumn.name;
                     let fieldSchema = table.schema[columnName];
                     if (!fieldSchema) {
-                        fieldSchema = Object.assign({ autocolumn: OracleIntegration.isAutoColumn(oracleColumn), name: columnName }, this.internalConvertType(oracleColumn));
+                        fieldSchema = Object.assign({ autocolumn: OracleIntegration.isAutoColumn(oracleColumn), name: columnName, constraints: {
+                                presence: false,
+                            } }, this.internalConvertType(oracleColumn));
                         table.schema[columnName] = fieldSchema;
                     }
                     // iterate each constraint on the column
@@ -255,6 +257,11 @@ class OracleIntegration extends sql_1.default {
                         if (oracleConstraint.type === OracleContraintTypes.PRIMARY) {
                             table.primary.push(columnName);
                         }
+                        else if (oracleConstraint.type === OracleContraintTypes.NOT_NULL_OR_CHECK) {
+                            table.schema[columnName].constraints = {
+                                presence: true,
+                            };
+                        }
                     });
                 });
             });

package/dist/integrations/postgres.js

@@ -15,8 +15,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const types_1 = require("@budibase/types");
 const utils_1 = require("./utils");
 const sql_1 = __importDefault(require("./base/sql"));
+const utilities_1 = require("../utilities");
 const { Client, types } = require("pg");
-const { escapeDangerousCharacters } = require("../utilities");
 // Return "date" and "timestamp" types as plain strings.
 // This lets us reference the original stored timezone.
 // types is undefined when running in a test env for some reason.
@@ -163,7 +163,7 @@ class PostgresIntegration extends sql_1.default {
                 const matches = query.sql.match(JSON_REGEX);
                 if (matches && matches.length > 0) {
                     for (let match of matches) {
-                        const escaped = escapeDangerousCharacters(match);
+                        const escaped = (0, utilities_1.escapeDangerousCharacters)(match);
                         query.sql = query.sql.replace(match, escaped);
                     }
                 }
@@ -227,11 +227,14 @@ class PostgresIntegration extends sql_1.default {
                     const identity = !!(column.identity_generation ||
                         column.identity_start ||
                         column.identity_increment);
+                    const constraints = {
+                        presence: column.is_nullable === "NO",
+                    };
                     const hasDefault = typeof column.column_default === "string" &&
                         column.column_default.startsWith("nextval");
                     const isGenerated = column.is_generated && column.is_generated !== "NEVER";
                     const isAuto = hasDefault || identity || isGenerated;
-                    tables[tableName].schema[columnName] = Object.assign(Object.assign({ autocolumn: isAuto, name: columnName }, (0, utils_1.convertSqlType)(column.data_type)), { externalType: column.data_type });
+                    tables[tableName].schema[columnName] = Object.assign(Object.assign({ autocolumn: isAuto, name: columnName, constraints }, (0, utils_1.convertSqlType)(column.data_type)), { externalType: column.data_type });
                 }
                 const final = (0, utils_1.finaliseExternalTables)(tables, entities);
                 this.tables = final.tables;

package/dist/integrations/s3.js

@@ -11,6 +11,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 const types_1 = require("@budibase/types");
 const AWS = require("aws-sdk");
+const csv = 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.",
@@ -41,16 +42,106 @@ const SCHEMA = {
         },
     },
     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: "string",
+                    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,
+            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) {
@@ -63,16 +154,81 @@ class S3Integration {
         }
         this.client = new AWS.S3(this.config);
     }
+    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 = csv()
+                    .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,

package/dist/middleware/appInfo.js

@@ -1,17 +1,22 @@
 "use strict";
-const { isDevAppID, isProdAppID } = require("../db/utils");
-exports.AppType = {
-    DEV: "dev",
-    PROD: "prod",
-};
-exports.middleware =
-    ({ appType } = {}) => (ctx, next) => {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.middleware = exports.AppType = void 0;
+const utils_1 = require("../db/utils");
+var AppType;
+(function (AppType) {
+    AppType["DEV"] = "dev";
+    AppType["PROD"] = "prod";
+})(AppType = exports.AppType || (exports.AppType = {}));
+function middleware({ appType } = {}) {
+    return (ctx, next) => {
         const appId = ctx.appId;
-        if (appType === exports.AppType.DEV && appId && !isDevAppID(appId)) {
+        if (appType === AppType.DEV && appId && !(0, utils_1.isDevAppID)(appId)) {
             ctx.throw(400, "Only apps in development support this endpoint");
         }
-        if (appType === exports.AppType.PROD && appId && !isProdAppID(appId)) {
+        if (appType === AppType.PROD && appId && !(0, utils_1.isProdAppID)(appId)) {
             ctx.throw(400, "Only apps in production support this endpoint");
         }
         return next();
     };
+}
+exports.middleware = middleware;