@budibase/server 0.9.188 → 0.9.190-alpha.2

package/dist/integrations/oracle.js

@@ -0,0 +1,347 @@
+"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/postgres.js

@@ -15,8 +15,6 @@ var PostgresModule;
 (function (PostgresModule) {
     const { Pool } = require("pg");
     const Sql = require("./base/sql");
-    const { FieldTypes } = require("../constants");
-    const { buildExternalTableId, convertType, copyExistingPropsOver, } = require("./utils");
     const { escapeDangerousCharacters } = require("../utilities");
     const JSON_REGEX = /'{.*}'::json/s;
     const SCHEMA = {
@@ -50,6 +48,11 @@ var PostgresModule;
                 default: "root",
                 required: true,
             },
+            schema: {
+                type: datasource_1.DatasourceFieldTypes.STRING,
+                default: "public",
+                required: true,
+            },
             ssl: {
                 type: datasource_1.DatasourceFieldTypes.BOOLEAN,
                 default: false,
@@ -81,21 +84,6 @@ var PostgresModule;
             },
         },
     };
-    const TYPE_MAP = {
-        text: FieldTypes.LONGFORM,
-        varchar: FieldTypes.STRING,
-        integer: FieldTypes.NUMBER,
-        bigint: FieldTypes.NUMBER,
-        decimal: FieldTypes.NUMBER,
-        smallint: FieldTypes.NUMBER,
-        real: FieldTypes.NUMBER,
-        "double precision": FieldTypes.NUMBER,
-        timestamp: FieldTypes.DATETIME,
-        time: FieldTypes.DATETIME,
-        boolean: FieldTypes.BOOLEAN,
-        json: FieldTypes.JSON,
-        date: FieldTypes.DATETIME,
-    };
     function internalQuery(client, query) {
         return __awaiter(this, void 0, void 0, function* () {
             // need to handle a specific issue with json data types in postgres,
@@ -120,8 +108,9 @@ var PostgresModule;
     }
     class PostgresIntegration extends Sql {
         constructor(config) {
-            super("pg");
-            this.COLUMNS_SQL = "select * from information_schema.columns where not table_schema = 'information_schema' and not table_schema = 'pg_catalog'";
+            super(utils_1.SqlClients.POSTGRES);
+            this.tables = {};
+            this.schemaErrors = {};
             this.PRIMARY_KEYS_SQL = `
     select tc.table_schema, tc.table_name, kc.column_name as primary_key 
     from information_schema.table_constraints tc
@@ -142,6 +131,16 @@ var PostgresModule;
                 this.pool = new Pool(newConfig);
             }
             this.client = this.pool;
+            this.setSchema();
+        }
+        setSchema() {
+            if (!this.config.schema) {
+                this.config.schema = "public";
+            }
+            this.client.on("connect", (client) => {
+                client.query(`SET search_path TO ${this.config.schema}`);
+            });
+            this.COLUMNS_SQL = `select * from information_schema.columns where table_schema = '${this.config.schema}'`;
         }
         /**
          * Fetches the tables from the postgres table and assigns them to the datasource.
@@ -176,13 +175,13 @@ var PostgresModule;
                     // table key doesn't exist yet
                     if (!tables[tableName] || !tables[tableName].schema) {
                         tables[tableName] = {
-                            _id: buildExternalTableId(datasourceId, tableName),
-                            primary: tableKeys[tableName] || ["id"],
+                            _id: utils_1.buildExternalTableId(datasourceId, tableName),
+                            primary: tableKeys[tableName] || [],
                             name: tableName,
                             schema: {},
                         };
                     }
-                    const type = convertType(column.data_type, TYPE_MAP);
+                    const type = utils_1.convertSqlType(column.data_type);
                     const identity = !!(column.identity_generation ||
                         column.identity_start ||
                         column.identity_increment);
@@ -196,10 +195,9 @@ var PostgresModule;
                         type,
                     };
                 }
-                for (let tableName of Object.keys(tables)) {
-                    copyExistingPropsOver(tableName, tables, entities);
-                }
-                this.tables = tables;
+                const final = utils_1.finaliseExternalTables(tables, entities);
+                this.tables = final.tables;
+                this.schemaErrors = final.errors;
             });
         }
         create(query) {
@@ -230,8 +228,17 @@ var PostgresModule;
             return __awaiter(this, void 0, void 0, function* () {
                 const operation = this._operation(json).toLowerCase();
                 const input = this._query(json);
-                const response = yield internalQuery(this.client, input);
-                return response.rows.length ? response.rows : [{ [operation]: true }];
+                if (Array.isArray(input)) {
+                    const responses = [];
+                    for (let query of input) {
+                        responses.push(yield internalQuery(this.client, query));
+                    }
+                    return responses;
+                }
+                else {
+                    const response = yield internalQuery(this.client, input);
+                    return response.rows.length ? response.rows : [{ [operation]: true }];
+                }
             });
         }
     }

package/dist/integrations/utils.js

@@ -1,11 +1,48 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.copyExistingPropsOver = exports.isIsoDateString = exports.isSQL = exports.getSqlQuery = exports.convertType = exports.breakRowIdField = exports.convertRowId = exports.isRowId = exports.generateRowIdField = exports.breakExternalTableId = exports.buildExternalTableId = exports.isExternalTable = void 0;
+exports.finaliseExternalTables = exports.isIsoDateString = exports.isSQL = exports.getSqlQuery = exports.convertSqlType = exports.breakRowIdField = exports.convertRowId = exports.isRowId = exports.generateRowIdField = exports.breakExternalTableId = exports.buildExternalTableId = exports.isExternalTable = exports.SqlClients = void 0;
 const datasource_1 = require("../definitions/datasource");
 const { DocumentTypes, SEPARATOR } = require("../db/utils");
-const { FieldTypes } = require("../constants");
+const { FieldTypes, BuildSchemaErrors, InvalidColumns, } = require("../constants");
 const DOUBLE_SEPARATOR = `${SEPARATOR}${SEPARATOR}`;
 const ROW_ID_REGEX = /^\[.*]$/g;
+const SQL_TYPE_MAP = {
+    text: FieldTypes.LONGFORM,
+    varchar: FieldTypes.STRING,
+    integer: FieldTypes.NUMBER,
+    bigint: FieldTypes.NUMBER,
+    decimal: FieldTypes.NUMBER,
+    smallint: FieldTypes.NUMBER,
+    real: FieldTypes.NUMBER,
+    "double precision": FieldTypes.NUMBER,
+    timestamp: FieldTypes.DATETIME,
+    time: FieldTypes.DATETIME,
+    boolean: FieldTypes.BOOLEAN,
+    json: FieldTypes.JSON,
+    date: FieldTypes.DATETIME,
+    blob: FieldTypes.LONGFORM,
+    enum: FieldTypes.STRING,
+    float: FieldTypes.NUMBER,
+    int: FieldTypes.NUMBER,
+    numeric: FieldTypes.NUMBER,
+    mediumint: FieldTypes.NUMBER,
+    dec: FieldTypes.NUMBER,
+    double: FieldTypes.NUMBER,
+    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);
 }
@@ -66,15 +103,15 @@ function breakRowIdField(_id) {
     }
 }
 exports.breakRowIdField = breakRowIdField;
-function convertType(type, map) {
-    for (let [external, internal] of Object.entries(map)) {
+function convertSqlType(type) {
+    for (let [external, internal] of Object.entries(SQL_TYPE_MAP)) {
         if (type.toLowerCase().includes(external)) {
             return internal;
         }
     }
     return FieldTypes.STRING;
 }
-exports.convertType = convertType;
+exports.convertSqlType = convertSqlType;
 function getSqlQuery(query) {
     if (typeof query === "string") {
         return { sql: query };
@@ -101,10 +138,10 @@ function isIsoDateString(str) {
 }
 exports.isIsoDateString = isIsoDateString;
 // add the existing relationships from the entities if they exist, to prevent them from being overridden
-function copyExistingPropsOver(tableName, tables, entities) {
+function copyExistingPropsOver(tableName, table, entities) {
     if (entities && entities[tableName]) {
         if (entities[tableName].primaryDisplay) {
-            tables[tableName].primaryDisplay = entities[tableName].primaryDisplay;
+            table.primaryDisplay = entities[tableName].primaryDisplay;
         }
         const existingTableSchema = entities[tableName].schema;
         for (let key in existingTableSchema) {
@@ -112,9 +149,34 @@ function copyExistingPropsOver(tableName, tables, entities) {
                 continue;
             }
             if (existingTableSchema[key].type === "link") {
-                tables[tableName].schema[key] = existingTableSchema[key];
+                table.schema[key] = existingTableSchema[key];
             }
         }
     }
+    return table;
 }
-exports.copyExistingPropsOver = copyExistingPropsOver;
+function finaliseExternalTables(tables, entities) {
+    const invalidColumns = Object.values(InvalidColumns);
+    let finalTables = {};
+    const errors = {};
+    for (let [name, table] of Object.entries(tables)) {
+        const schemaFields = Object.keys(table.schema);
+        // make sure every table has a key
+        if (table.primary == null || table.primary.length === 0) {
+            errors[name] = BuildSchemaErrors.NO_KEY;
+            continue;
+        }
+        else if (schemaFields.find(field => invalidColumns.includes(field))) {
+            errors[name] = BuildSchemaErrors.INVALID_COLUMN;
+            continue;
+        }
+        // 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;

package/dist/middleware/authorized.js

@@ -18,7 +18,8 @@ function hasResource(ctx) {
 module.exports =
     (permType, permLevel = null) => (ctx, next) => __awaiter(void 0, void 0, void 0, function* () {
         // webhooks don't need authentication, each webhook unique
-        if (isWebhookEndpoint(ctx)) {
+        // also internal requests (between services) don't need authorized
+        if (isWebhookEndpoint(ctx) || ctx.internal) {
             return next();
         }
         if (!ctx.user) {

package/dist/middleware/builder.js

@@ -13,6 +13,7 @@ const { doesUserHaveLock, updateLock, checkDebounce, setDebounce, } = require(".
 const CouchDB = require("../db");
 const { DocumentTypes } = require("../db/utils");
 const { PermissionTypes } = require("@budibase/auth/permissions");
+const { app: appCache } = require("@budibase/auth/cache");
 const DEBOUNCE_TIME_SEC = 30;
 /************************************************** *
  * This middleware has been broken out of the       *
@@ -51,7 +52,9 @@ function updateAppUpdatedAt(ctx) {
         const db = new CouchDB(appId);
         const metadata = yield db.get(DocumentTypes.APP_METADATA);
         metadata.updatedAt = new Date().toISOString();
-        yield db.put(metadata);
+        const response = yield db.put(metadata);
+        metadata._rev = response.rev;
+        yield appCache.invalidateAppMetadata(appId, metadata);
         // set a new debounce record with a short TTL
         yield setDebounce(appId, DEBOUNCE_TIME_SEC);
     });