@budibase/server 2.6.19-alpha.2 → 2.6.19-alpha.20

package/dist/integrations/mysql.js

@@ -1,272 +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 utils_1 = require("./utils");
-const dayjs_1 = __importDefault(require("dayjs"));
-const utilities_1 = require("../utilities");
-const sql_1 = __importDefault(require("./base/sql"));
-const promise_1 = __importDefault(require("mysql2/promise"));
-const SCHEMA = {
-    docs: "https://github.com/sidorares/node-mysql2",
-    plus: true,
-    friendlyName: "MySQL",
-    type: "Relational",
-    description: "MySQL Database Service is a fully managed database service to deploy cloud-native applications. ",
-    features: [types_1.DatasourceFeature.CONNECTION_CHECKING],
-    datasource: {
-        host: {
-            type: types_1.DatasourceFieldType.STRING,
-            default: "localhost",
-            required: true,
-        },
-        port: {
-            type: types_1.DatasourceFieldType.NUMBER,
-            default: 3306,
-            required: false,
-        },
-        user: {
-            type: types_1.DatasourceFieldType.STRING,
-            default: "root",
-            required: true,
-        },
-        password: {
-            type: types_1.DatasourceFieldType.PASSWORD,
-            default: "root",
-            required: true,
-        },
-        database: {
-            type: types_1.DatasourceFieldType.STRING,
-            required: true,
-        },
-        ssl: {
-            type: types_1.DatasourceFieldType.OBJECT,
-            required: false,
-        },
-        rejectUnauthorized: {
-            type: types_1.DatasourceFieldType.BOOLEAN,
-            default: true,
-            required: false,
-        },
-    },
-    query: {
-        create: {
-            type: types_1.QueryType.SQL,
-        },
-        read: {
-            type: types_1.QueryType.SQL,
-        },
-        update: {
-            type: types_1.QueryType.SQL,
-        },
-        delete: {
-            type: types_1.QueryType.SQL,
-        },
-    },
-};
-function bindingTypeCoerce(bindings) {
-    for (let i = 0; i < bindings.length; i++) {
-        const binding = bindings[i];
-        if (typeof binding !== "string") {
-            continue;
-        }
-        const matches = binding.match(utilities_1.NUMBER_REGEX);
-        // check if number first
-        if (matches && matches[0] !== "" && !isNaN(Number(matches[0]))) {
-            bindings[i] = parseFloat(binding);
-        }
-        // if not a number, see if it is a date - important to do in this order as any
-        // integer will be considered a valid date
-        else if (/^\d/.test(binding) &&
-            (0, dayjs_1.default)(binding).isValid() &&
-            !binding.includes(",")) {
-            bindings[i] = (0, dayjs_1.default)(binding).toDate();
-        }
-    }
-    return bindings;
-}
-class MySQLIntegration extends sql_1.default {
-    constructor(config) {
-        super(utils_1.SqlClient.MY_SQL);
-        this.tables = {};
-        this.schemaErrors = {};
-        this.config = config;
-        if (config.ssl && Object.keys(config.ssl).length === 0) {
-            delete config.ssl;
-        }
-        // make sure this defaults to true
-        if (config.rejectUnauthorized != null &&
-            !config.rejectUnauthorized &&
-            config.ssl &&
-            typeof config.ssl !== "string") {
-            config.ssl.rejectUnauthorized = config.rejectUnauthorized;
-        }
-        // @ts-ignore
-        delete config.rejectUnauthorized;
-        this.config = Object.assign(Object.assign({}, config), { multipleStatements: true, typeCast: function (field, next) {
-                var _a;
-                if (field.type == "DATETIME" ||
-                    field.type === "DATE" ||
-                    field.type === "TIMESTAMP" ||
-                    field.type === "LONGLONG") {
-                    return field.string();
-                }
-                if (field.type === "BIT" && field.length === 1) {
-                    return (_a = field.buffer()) === null || _a === void 0 ? void 0 : _a[0];
-                }
-                return next();
-            } });
-    }
-    testConnection() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const response = {
-                connected: false,
-            };
-            try {
-                const [result] = yield this.internalQuery({ sql: "SELECT 1+1 AS checkRes" }, { connect: true });
-                response.connected = (result === null || result === void 0 ? void 0 : result.checkRes) == 2;
-            }
-            catch (e) {
-                response.error = e.message;
-            }
-            return response;
-        });
-    }
-    getBindingIdentifier() {
-        return "?";
-    }
-    getStringConcat(parts) {
-        return `concat(${parts.join(", ")})`;
-    }
-    connect() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.client = yield promise_1.default.createConnection(this.config);
-        });
-    }
-    disconnect() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.client.end();
-        });
-    }
-    internalQuery(query, opts = {
-        connect: true,
-        disableCoercion: false,
-    }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                if (opts === null || opts === void 0 ? void 0 : opts.connect) {
-                    yield this.connect();
-                }
-                const baseBindings = query.bindings || [];
-                const bindings = (opts === null || opts === void 0 ? void 0 : opts.disableCoercion)
-                    ? baseBindings
-                    : bindingTypeCoerce(baseBindings);
-                // Node MySQL is callback based, so we must wrap our call in a promise
-                const response = yield this.client.query(query.sql, bindings);
-                return response[0];
-            }
-            finally {
-                if ((opts === null || opts === void 0 ? void 0 : opts.connect) && this.client) {
-                    yield this.disconnect();
-                }
-            }
-        });
-    }
-    buildSchema(datasourceId, entities) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const tables = {};
-            const database = this.config.database;
-            yield this.connect();
-            try {
-                // get the tables first
-                const tablesResp = yield this.internalQuery({ sql: "SHOW TABLES;" }, { connect: false });
-                const tableNames = tablesResp.map((obj) => obj[`Tables_in_${database}`] ||
-                    obj[`Tables_in_${database.toLowerCase()}`]);
-                for (let tableName of tableNames) {
-                    const primaryKeys = [];
-                    const schema = {};
-                    const descResp = yield this.internalQuery({ sql: `DESCRIBE \`${tableName}\`;` }, { connect: false });
-                    for (let column of descResp) {
-                        const columnName = column.Field;
-                        if (column.Key === "PRI" && primaryKeys.indexOf(column.Key) === -1) {
-                            primaryKeys.push(columnName);
-                        }
-                        const hasDefault = column.Default != null;
-                        const isAuto = typeof column.Extra === "string" &&
-                            (column.Extra === "auto_increment" ||
-                                column.Extra.toLowerCase().includes("generated"));
-                        const required = column.Null !== "YES";
-                        const constraints = {
-                            presence: required && !isAuto && !hasDefault,
-                        };
-                        schema[columnName] = Object.assign(Object.assign({ name: columnName, autocolumn: isAuto, constraints }, (0, utils_1.convertSqlType)(column.Type)), { externalType: column.Type });
-                    }
-                    if (!tables[tableName]) {
-                        tables[tableName] = {
-                            _id: (0, utils_1.buildExternalTableId)(datasourceId, tableName),
-                            primary: primaryKeys,
-                            name: tableName,
-                            schema,
-                        };
-                    }
-                }
-            }
-            finally {
-                yield this.disconnect();
-            }
-            const final = (0, utils_1.finaliseExternalTables)(tables, entities);
-            this.tables = final.tables;
-            this.schemaErrors = final.errors;
-        });
-    }
-    create(query) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const results = yield this.internalQuery((0, utils_1.getSqlQuery)(query));
-            return results.length ? results : [{ created: true }];
-        });
-    }
-    read(query) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.internalQuery((0, utils_1.getSqlQuery)(query));
-        });
-    }
-    update(query) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const results = yield this.internalQuery((0, utils_1.getSqlQuery)(query));
-            return results.length ? results : [{ updated: true }];
-        });
-    }
-    delete(query) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const results = yield this.internalQuery((0, utils_1.getSqlQuery)(query));
-            return results.length ? results : [{ deleted: true }];
-        });
-    }
-    query(json) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.connect();
-            try {
-                const queryFn = (query) => this.internalQuery(query, { connect: false, disableCoercion: true });
-                return yield this.queryWithReturning(json, queryFn);
-            }
-            finally {
-                yield this.disconnect();
-            }
-        });
-    }
-}
-exports.default = {
-    schema: SCHEMA,
-    integration: MySQLIntegration,
-};

package/dist/integrations/oracle.js

@@ -1,404 +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 utils_1 = require("./utils");
-const sql_1 = __importDefault(require("./base/sql"));
-const constants_1 = require("../constants");
-let oracledb;
-try {
-    oracledb = require("oracledb");
-    oracledb.outFormat = oracledb.OUT_FORMAT_OBJECT;
-}
-catch (err) {
-    console.log("ORACLEDB is not installed");
-}
-const SCHEMA = {
-    docs: "https://github.com/oracle/node-oracledb",
-    plus: true,
-    friendlyName: "Oracle",
-    type: "Relational",
-    description: "Oracle Database is an object-relational database management system developed by Oracle Corporation",
-    features: [types_1.DatasourceFeature.CONNECTION_CHECKING],
-    datasource: {
-        host: {
-            type: types_1.DatasourceFieldType.STRING,
-            default: "localhost",
-            required: true,
-        },
-        port: {
-            type: types_1.DatasourceFieldType.NUMBER,
-            required: true,
-            default: 1521,
-        },
-        database: {
-            type: types_1.DatasourceFieldType.STRING,
-            required: true,
-            display: "Service Name",
-        },
-        user: {
-            type: types_1.DatasourceFieldType.STRING,
-            required: true,
-        },
-        password: {
-            type: types_1.DatasourceFieldType.PASSWORD,
-            required: true,
-        },
-    },
-    query: {
-        create: {
-            type: types_1.QueryType.SQL,
-        },
-        read: {
-            type: types_1.QueryType.SQL,
-        },
-        update: {
-            type: types_1.QueryType.SQL,
-        },
-        delete: {
-            type: types_1.QueryType.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.SqlClient.ORACLE);
-        this.index = 1;
-        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.password,
-                connectString,
-            };
-            return oracledb.getConnection(attributes);
-        });
-        this.config = config;
-    }
-    getBindingIdentifier() {
-        return `:${this.index++}`;
-    }
-    getStringConcat(parts) {
-        return parts.join(" || ");
-    }
-    static isInstalled() {
-        return oracledb != null;
-    }
-    /**
-     * 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;
-    }
-    static isSupportedColumn(column) {
-        return !UNSUPPORTED_TYPES.includes(column.type);
-    }
-    static isAutoColumn(column) {
-        return !!(column.default && column.default.toLowerCase().includes("nextval"));
-    }
-    /**
-     * 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) {
-        return (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);
-    }
-    internalConvertType(column) {
-        if (this.isBooleanType(column)) {
-            return { type: constants_1.FieldTypes.BOOLEAN };
-        }
-        return (0, 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: (0, 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 => OracleIntegration.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 = Object.assign({ autocolumn: OracleIntegration.isAutoColumn(oracleColumn), name: columnName, constraints: {
-                                presence: false,
-                            } }, 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);
-                        }
-                        else if (oracleConstraint.type === OracleContraintTypes.NOT_NULL_OR_CHECK) {
-                            table.schema[columnName].constraints = {
-                                presence: true,
-                            };
-                        }
-                    });
-                });
-            });
-            const final = (0, utils_1.finaliseExternalTables)(tables, entities);
-            this.tables = final.tables;
-            this.schemaErrors = final.errors;
-        });
-    }
-    testConnection() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const response = {
-                connected: false,
-            };
-            let connection;
-            try {
-                connection = yield this.getConnection();
-                response.connected = true;
-            }
-            catch (err) {
-                response.connected = false;
-                response.error = err.message;
-            }
-            finally {
-                if (connection) {
-                    try {
-                        yield connection.close();
-                    }
-                    catch (err) {
-                        response.connected = false;
-                        response.error = err.message;
-                    }
-                }
-            }
-            return response;
-        });
-    }
-    internalQuery(query) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let connection;
-            try {
-                this.index = 1;
-                connection = yield this.getConnection();
-                const options = { autoCommit: true };
-                const bindings = query.bindings || [];
-                return yield connection.execute(query.sql, bindings, options);
-            }
-            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((0, 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((0, utils_1.getSqlQuery)(query));
-            return response.rows ? response.rows : [];
-        });
-    }
-    update(query) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const response = yield this.internalQuery((0, 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((0, utils_1.getSqlQuery)(query));
-            return response.rows && response.rows.length
-                ? response.rows
-                : [{ deleted: true }];
-        });
-    }
-    query(json) {
-        var _a, _b, _c;
-        return __awaiter(this, void 0, void 0, function* () {
-            const operation = this._operation(json);
-            const input = this._query(json, { disableReturning: true });
-            if (Array.isArray(input)) {
-                const responses = [];
-                for (let query of input) {
-                    responses.push(yield this.internalQuery(query));
-                }
-                return responses;
-            }
-            else {
-                // read the row to be deleted up front for the return
-                let deletedRows;
-                if (operation === types_1.Operation.DELETE) {
-                    const queryFn = (query) => this.internalQuery(query);
-                    deletedRows = yield this.getReturningRow(queryFn, json);
-                }
-                // run the query
-                const response = yield this.internalQuery(input);
-                // get the results or return the created / updated / deleted row
-                if ((_a = deletedRows === null || deletedRows === void 0 ? void 0 : deletedRows.rows) === null || _a === void 0 ? void 0 : _a.length) {
-                    return deletedRows.rows;
-                }
-                else if ((_b = response.rows) === null || _b === void 0 ? void 0 : _b.length) {
-                    return response.rows;
-                }
-                else {
-                    // get the last row that was updated
-                    if (response.lastRowid &&
-                        ((_c = json.endpoint) === null || _c === void 0 ? void 0 : _c.entityId) &&
-                        operation !== types_1.Operation.DELETE) {
-                        const lastRow = yield this.internalQuery({
-                            sql: `SELECT * FROM \"${json.endpoint.entityId}\" WHERE ROWID = '${response.lastRowid}'`,
-                        });
-                        return lastRow.rows;
-                    }
-                    else {
-                        return [{ [operation.toLowerCase()]: true }];
-                    }
-                }
-            }
-        });
-    }
-}
-exports.default = {
-    schema: SCHEMA,
-    integration: OracleIntegration,
-};