@budibase/server 0.9.185-alpha.14 → 0.9.185-alpha.18

package/coverage/lcov.info

@@ -791,17 +791,17 @@ DA:14,1
 DA:20,1
 DA:21,1
 DA:22,1
-DA:23,46
+DA:23,47
 DA:24,1
-DA:26,45
-DA:27,45
+DA:26,46
+DA:27,46
 DA:34,1
 LF:18
 LH:18
 BRDA:6,0,0,1
 BRDA:6,0,1,0
 BRDA:23,1,0,1
-BRDA:23,1,1,45
+BRDA:23,1,1,46
 BRF:4
 BRH:3
 end_of_record
@@ -5781,27 +5781,27 @@ TN:
 SF:src/constants/index.js
 FNF:0
 FNH:0
-DA:1,40
-DA:2,40
-DA:3,40
-DA:5,40
-DA:9,40
-DA:22,40
-DA:23,40
-DA:32,40
-DA:48,40
-DA:55,40
-DA:61,40
-DA:67,40
-DA:78,40
-DA:83,40
-DA:145,40
-DA:153,40
-DA:154,40
-DA:161,40
-DA:166,40
-DA:172,40
-DA:178,40
+DA:1,41
+DA:2,41
+DA:3,41
+DA:5,41
+DA:9,41
+DA:22,41
+DA:23,41
+DA:32,41
+DA:48,41
+DA:55,41
+DA:61,41
+DA:67,41
+DA:78,41
+DA:83,41
+DA:145,41
+DA:153,41
+DA:154,41
+DA:161,41
+DA:166,41
+DA:172,41
+DA:178,41
 LF:21
 LH:21
 BRF:0
@@ -5929,8 +5929,8 @@ FN:3,(anonymous_0)
 FNF:1
 FNH:1
 FNDA:803,(anonymous_0)
-DA:1,46
-DA:3,46
+DA:1,47
+DA:3,47
 DA:4,803
 LF:3
 LH:3
@@ -6001,113 +6001,113 @@ FNDA:0,(anonymous_26)
 FNDA:1,(anonymous_27)
 FNDA:0,(anonymous_28)
 FNDA:60,(anonymous_29)
-DA:1,46
-DA:12,46
-DA:14,46
-DA:16,46
-DA:22,46
-DA:45,46
-DA:50,46
-DA:54,46
-DA:58,46
-DA:60,46
-DA:68,46
-DA:69,46
-DA:70,46
-DA:71,46
-DA:72,46
-DA:73,46
-DA:74,46
-DA:75,46
-DA:76,46
-DA:77,46
-DA:78,46
-DA:79,46
-DA:80,46
-DA:81,46
-DA:83,46
-DA:84,46
-DA:86,46
+DA:1,47
+DA:12,47
+DA:14,47
+DA:16,47
+DA:22,47
+DA:45,47
+DA:50,47
+DA:54,47
+DA:58,47
+DA:60,47
+DA:68,47
+DA:69,47
+DA:70,47
+DA:71,47
+DA:72,47
+DA:73,47
+DA:74,47
+DA:75,47
+DA:76,47
+DA:77,47
+DA:78,47
+DA:79,47
+DA:80,47
+DA:81,47
+DA:83,47
+DA:84,47
+DA:86,47
 DA:87,74
 DA:103,603
 DA:104,590
 DA:106,603
-DA:113,46
-DA:118,46
+DA:113,47
+DA:118,47
 DA:119,3
-DA:126,46
+DA:126,47
 DA:127,99
-DA:138,46
+DA:138,47
 DA:139,11
 DA:140,0
 DA:143,11
 DA:145,11
-DA:154,46
+DA:154,47
 DA:155,200
 DA:156,200
-DA:162,46
+DA:162,47
 DA:163,3
-DA:171,46
+DA:171,47
 DA:172,132
-DA:178,46
+DA:178,47
 DA:179,2
 DA:180,2
 DA:181,1
 DA:183,1
-DA:189,46
+DA:189,47
 DA:190,203
-DA:197,46
+DA:197,47
 DA:198,20
-DA:212,46
+DA:212,47
 DA:220,9
 DA:221,9
 DA:222,9
 DA:223,9
-DA:229,46
+DA:229,47
 DA:230,0
-DA:237,46
+DA:237,47
 DA:238,178
 DA:239,178
 DA:240,0
 DA:242,178
-DA:249,46
+DA:249,47
 DA:250,178
 DA:251,178
 DA:252,178
-DA:259,46
+DA:259,47
 DA:260,5
-DA:266,46
+DA:266,47
 DA:267,188
-DA:274,46
+DA:274,47
 DA:275,197
-DA:281,46
+DA:281,47
 DA:282,190
-DA:289,46
+DA:289,47
 DA:290,10
-DA:296,46
+DA:296,47
 DA:297,2
-DA:304,46
+DA:304,47
 DA:305,23
-DA:313,46
+DA:313,47
 DA:314,3
-DA:321,46
+DA:321,47
 DA:322,18
-DA:330,46
+DA:330,47
 DA:331,3
 DA:332,2
 DA:335,1
-DA:342,46
+DA:342,47
 DA:343,10
-DA:346,46
+DA:346,47
 DA:347,0
 DA:348,0
 DA:349,0
 DA:351,0
-DA:354,46
+DA:354,47
 DA:355,1
-DA:358,46
+DA:358,47
 DA:359,0
-DA:365,46
+DA:365,47
 DA:366,60
 LF:108
 LH:100

package/dist/definitions/datasource.js

@@ -48,6 +48,7 @@ var SourceNames;
     SourceNames["MYSQL"] = "MYSQL";
     SourceNames["ARANGODB"] = "ARANGODB";
     SourceNames["REST"] = "REST";
+    SourceNames["ORACLE"] = "ORACLE";
 })(SourceNames = exports.SourceNames || (exports.SourceNames = {}));
 var IncludeRelationships;
 (function (IncludeRelationships) {

package/dist/integrations/base/sql.js

@@ -379,6 +379,9 @@ class SqlQueryBuilder extends sqlTable_1.default {
                 else if (sqlClient === utils_1.SqlClients.MY_SQL) {
                     id = results === null || results === void 0 ? void 0 : results.insertId;
                 }
+                else if (sqlClient === utils_1.SqlClients.ORACLE) {
+                    id = response.outBinds[0][0];
+                }
                 row = processFn(yield this.getReturningRow(queryFn, this.checkLookupKeys(id, json)));
             }
             if (operation !== datasource_1.Operation.READ) {
@@ -388,4 +391,5 @@ class SqlQueryBuilder extends sqlTable_1.default {
         });
     }
 }
+exports.default = SqlQueryBuilder;
 module.exports = SqlQueryBuilder;

package/dist/integrations/index.js

@@ -37,6 +37,12 @@ const INTEGRATIONS = {
     [SourceNames.ARANGODB]: arangodb.integration,
     [SourceNames.REST]: rest.integration,
 };
+// optionally add oracle integration if the oracle binary can be installed
+if (!(process.arch === 'arm64' && process.platform === 'darwin')) {
+    const oracle = require("./oracle");
+    DEFINITIONS[SourceNames.ORACLE] = oracle.schema;
+    INTEGRATIONS[SourceNames.ORACLE] = oracle.integration;
+}
 module.exports = {
     definitions: DEFINITIONS,
     integrations: INTEGRATIONS,

package/dist/integrations/oracle.js

@@ -0,0 +1,345 @@
+"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 datasource_1 = require("../definitions/datasource");
+const utils_1 = require("./utils");
+const oracledb_1 = __importDefault(require("oracledb"));
+const sql_1 = __importDefault(require("./base/sql"));
+const constants_1 = require("../constants");
+var OracleModule;
+(function (OracleModule) {
+    oracledb_1.default.outFormat = oracledb_1.default.OUT_FORMAT_OBJECT;
+    const SCHEMA = {
+        docs: "https://github.com/oracle/node-oracledb",
+        plus: true,
+        friendlyName: "Oracle",
+        description: "Oracle Database is an object-relational database management system developed by Oracle Corporation",
+        datasource: {
+            host: {
+                type: datasource_1.DatasourceFieldTypes.STRING,
+                default: "localhost",
+                required: true,
+            },
+            port: {
+                type: datasource_1.DatasourceFieldTypes.NUMBER,
+                required: true,
+                default: 1521,
+            },
+            database: {
+                type: datasource_1.DatasourceFieldTypes.STRING,
+                required: true,
+            },
+            user: {
+                type: datasource_1.DatasourceFieldTypes.STRING,
+                required: true,
+            },
+            password: {
+                type: datasource_1.DatasourceFieldTypes.PASSWORD,
+                required: true,
+            },
+        },
+        query: {
+            create: {
+                type: datasource_1.QueryTypes.SQL,
+            },
+            read: {
+                type: datasource_1.QueryTypes.SQL,
+            },
+            update: {
+                type: datasource_1.QueryTypes.SQL,
+            },
+            delete: {
+                type: datasource_1.QueryTypes.SQL,
+            },
+        },
+    };
+    const UNSUPPORTED_TYPES = ["BLOB", "CLOB", "NCLOB"];
+    const OracleContraintTypes = {
+        PRIMARY: "P",
+        NOT_NULL_OR_CHECK: "C",
+        FOREIGN_KEY: "R",
+        UNIQUE: "U",
+    };
+    class OracleIntegration extends sql_1.default {
+        constructor(config) {
+            super(utils_1.SqlClients.ORACLE);
+            this.tables = {};
+            this.schemaErrors = {};
+            this.COLUMNS_SQL = `
+      SELECT
+        tabs.table_name,
+        cols.column_name,
+        cols.data_type,
+        cols.data_default,
+        cols.column_id,
+        cons.constraint_name,
+        cons.constraint_type,
+        cons.r_constraint_name,
+        cons.search_condition
+      FROM
+        user_tables tabs
+      JOIN 
+        user_tab_columns cols
+        ON tabs.table_name = cols.table_name 
+      LEFT JOIN 
+        user_cons_columns col_cons
+        ON cols.column_name = col_cons.column_name
+        AND cols.table_name = col_cons.table_name
+      LEFT JOIN 
+        user_constraints cons
+        ON col_cons.constraint_name = cons.constraint_name
+        AND cons.table_name = cols.table_name
+      WHERE
+        (cons.status = 'ENABLED'
+          OR cons.status IS NULL)
+    `;
+            this.getConnection = () => __awaiter(this, void 0, void 0, function* () {
+                //connectString : "(DESCRIPTION =(ADDRESS = (PROTOCOL = TCP)(HOST = localhost)(PORT = 1521))(CONNECT_DATA =(SID= ORCL)))"
+                const connectString = `${this.config.host}:${this.config.port || 1521}/${this.config.database}`;
+                const attributes = {
+                    user: this.config.user,
+                    password: this.config.user,
+                    connectString,
+                };
+                return oracledb_1.default.getConnection(attributes);
+            });
+            this.config = config;
+        }
+        /**
+         * Map the flat tabular columns and constraints data into a nested object
+         */
+        mapColumns(result) {
+            const oracleTables = {};
+            if (result.rows) {
+                result.rows.forEach(row => {
+                    const tableName = row.TABLE_NAME;
+                    const columnName = row.COLUMN_NAME;
+                    const dataType = row.DATA_TYPE;
+                    const dataDefault = row.DATA_DEFAULT;
+                    const columnId = row.COLUMN_ID;
+                    const constraintName = row.CONSTRAINT_NAME;
+                    const constraintType = row.CONSTRAINT_TYPE;
+                    const relatedConstraintName = row.R_CONSTRAINT_NAME;
+                    const searchCondition = row.SEARCH_CONDITION;
+                    let table = oracleTables[tableName];
+                    if (!table) {
+                        table = {
+                            name: tableName,
+                            columns: {},
+                        };
+                        oracleTables[tableName] = table;
+                    }
+                    let column = table.columns[columnName];
+                    if (!column) {
+                        column = {
+                            name: columnName,
+                            type: dataType,
+                            default: dataDefault,
+                            id: columnId,
+                            constraints: {},
+                        };
+                        table.columns[columnName] = column;
+                    }
+                    if (constraintName && constraintType) {
+                        let constraint = column.constraints[constraintName];
+                        if (!constraint) {
+                            constraint = {
+                                name: constraintName,
+                                type: constraintType,
+                                relatedConstraintName: relatedConstraintName,
+                                searchCondition: searchCondition,
+                            };
+                        }
+                        column.constraints[constraintName] = constraint;
+                    }
+                });
+            }
+            return oracleTables;
+        }
+        isSupportedColumn(column) {
+            if (UNSUPPORTED_TYPES.includes(column.type)) {
+                return false;
+            }
+            return true;
+        }
+        isAutoColumn(column) {
+            if (column.default && column.default.toLowerCase().includes("nextval")) {
+                return true;
+            }
+            return false;
+        }
+        /**
+         * No native boolean in oracle. Best we can do is to check if a manual 1 or 0 number constraint has been set up
+         * This matches the default behaviour for generating DDL used in knex.
+         */
+        isBooleanType(column) {
+            if (column.type.toLowerCase() === "number" &&
+                Object.values(column.constraints).filter(c => {
+                    if (c.type === OracleContraintTypes.NOT_NULL_OR_CHECK &&
+                        c.searchCondition) {
+                        const condition = c.searchCondition
+                            .replace(/\s/g, "") // remove spaces
+                            .replace(/[']+/g, ""); // remove quotes
+                        if (condition.includes("in(0,1)") ||
+                            condition.includes("in(1,0)")) {
+                            return true;
+                        }
+                    }
+                    return false;
+                }).length > 0) {
+                return true;
+            }
+            return false;
+        }
+        internalConvertType(column) {
+            if (this.isBooleanType(column)) {
+                return constants_1.FieldTypes.BOOLEAN;
+            }
+            return utils_1.convertSqlType(column.type);
+        }
+        /**
+         * Fetches the tables from the oracle table and assigns them to the datasource.
+         * @param {*} datasourceId - datasourceId to fetch
+         * @param entities - the tables that are to be built
+         */
+        buildSchema(datasourceId, entities) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const columnsResponse = yield this.internalQuery({
+                    sql: this.COLUMNS_SQL,
+                });
+                const oracleTables = this.mapColumns(columnsResponse);
+                const tables = {};
+                // iterate each table
+                Object.values(oracleTables).forEach(oracleTable => {
+                    let table = tables[oracleTable.name];
+                    if (!table) {
+                        table = {
+                            _id: utils_1.buildExternalTableId(datasourceId, oracleTable.name),
+                            primary: [],
+                            name: oracleTable.name,
+                            schema: {},
+                        };
+                        tables[oracleTable.name] = table;
+                    }
+                    // iterate each column on the table
+                    Object.values(oracleTable.columns)
+                        // remove columns that we can't read / save
+                        .filter(oracleColumn => this.isSupportedColumn(oracleColumn))
+                        // match the order of the columns in the db
+                        .sort((c1, c2) => c1.id - c2.id)
+                        .forEach(oracleColumn => {
+                        const columnName = oracleColumn.name;
+                        let fieldSchema = table.schema[columnName];
+                        if (!fieldSchema) {
+                            fieldSchema = {
+                                autocolumn: this.isAutoColumn(oracleColumn),
+                                name: columnName,
+                                type: this.internalConvertType(oracleColumn),
+                            };
+                            table.schema[columnName] = fieldSchema;
+                        }
+                        // iterate each constraint on the column
+                        Object.values(oracleColumn.constraints).forEach(oracleConstraint => {
+                            if (oracleConstraint.type === OracleContraintTypes.PRIMARY) {
+                                table.primary.push(columnName);
+                            }
+                        });
+                    });
+                });
+                const final = utils_1.finaliseExternalTables(tables, entities);
+                this.tables = final.tables;
+                this.schemaErrors = final.errors;
+            });
+        }
+        /**
+         * Knex default returning behaviour does not work with oracle
+         * Manually add the behaviour for the return column
+         */
+        addReturning(query, bindings, returnColumn) {
+            if (bindings instanceof Array) {
+                bindings.push({ dir: oracledb_1.default.BIND_OUT });
+                query.sql = query.sql + ` returning \"${returnColumn}\" into :${bindings.length}`;
+            }
+        }
+        internalQuery(query, returnColum, operation) {
+            return __awaiter(this, void 0, void 0, function* () {
+                let connection;
+                try {
+                    connection = yield this.getConnection();
+                    const options = { autoCommit: true };
+                    const bindings = query.bindings || [];
+                    if (returnColum && (operation === datasource_1.Operation.CREATE || operation === datasource_1.Operation.UPDATE)) {
+                        this.addReturning(query, bindings, returnColum);
+                    }
+                    const result = yield connection.execute(query.sql, bindings, options);
+                    return result;
+                }
+                finally {
+                    if (connection) {
+                        try {
+                            yield connection.close();
+                        }
+                        catch (err) {
+                            console.error(err);
+                        }
+                    }
+                }
+            });
+        }
+        create(query) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const response = yield this.internalQuery(utils_1.getSqlQuery(query));
+                return response.rows && response.rows.length
+                    ? response.rows
+                    : [{ created: true }];
+            });
+        }
+        read(query) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const response = yield this.internalQuery(utils_1.getSqlQuery(query));
+                return response.rows ? response.rows : [];
+            });
+        }
+        update(query) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const response = yield this.internalQuery(utils_1.getSqlQuery(query));
+                return response.rows && response.rows.length
+                    ? response.rows
+                    : [{ updated: true }];
+            });
+        }
+        delete(query) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const response = yield this.internalQuery(utils_1.getSqlQuery(query));
+                return response.rows && response.rows.length
+                    ? response.rows
+                    : [{ deleted: true }];
+            });
+        }
+        query(json) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const primaryKeys = json.meta.table.primary;
+                const primaryKey = primaryKeys ? primaryKeys[0] : undefined;
+                const queryFn = (query, operation) => this.internalQuery(query, primaryKey, operation);
+                const processFn = (response) => response.rows ? response.rows : [];
+                const output = yield this.queryWithReturning(json, queryFn, processFn);
+                return output;
+            });
+        }
+    }
+    module.exports = {
+        schema: SCHEMA,
+        integration: OracleIntegration,
+    };
+})(OracleModule || (OracleModule = {}));

package/dist/integrations/utils.js

@@ -31,12 +31,17 @@ const SQL_TYPE_MAP = {
     fixed: FieldTypes.NUMBER,
     datetime: FieldTypes.DATETIME,
     tinyint: FieldTypes.BOOLEAN,
+    long: FieldTypes.LONGFORM,
+    number: FieldTypes.NUMBER,
+    binary_float: FieldTypes.NUMBER,
+    binary_double: FieldTypes.NUMBER,
 };
 var SqlClients;
 (function (SqlClients) {
     SqlClients["MS_SQL"] = "mssql";
     SqlClients["POSTGRES"] = "pg";
     SqlClients["MY_SQL"] = "mysql";
+    SqlClients["ORACLE"] = "oracledb";
 })(SqlClients = exports.SqlClients || (exports.SqlClients = {}));
 function isExternalTable(tableId) {
     return tableId.includes(DocumentTypes.DATASOURCE);
@@ -152,7 +157,7 @@ function copyExistingPropsOver(tableName, table, entities) {
 }
 function finaliseExternalTables(tables, entities) {
     const invalidColumns = Object.values(InvalidColumns);
-    const finalTables = {};
+    let finalTables = {};
     const errors = {};
     for (let [name, table] of Object.entries(tables)) {
         const schemaFields = Object.keys(table.schema);
@@ -168,6 +173,10 @@ function finaliseExternalTables(tables, entities) {
         // make sure all previous props have been added back
         finalTables[name] = copyExistingPropsOver(name, table, entities);
     }
+    // sort the tables by name
+    finalTables = Object.entries(finalTables)
+        .sort(([a], [b]) => a.localeCompare(b))
+        .reduce((r, [k, v]) => (Object.assign(Object.assign({}, r), { [k]: v })), {});
     return { tables: finalTables, errors };
 }
 exports.finaliseExternalTables = finaliseExternalTables;