@budibase/server 2.6.23 → 2.6.24-alpha.0

package/dist/integrations/postgres.js

@@ -1,300 +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 utilities_1 = require("../utilities");
-const { Client, types } = require("pg");
-// 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.
-if (types) {
-    types.setTypeParser(1114, (val) => val); // timestamp
-    types.setTypeParser(1082, (val) => val); // date
-    types.setTypeParser(1184, (val) => val); // timestampz
-}
-const JSON_REGEX = /'{.*}'::json/s;
-const SCHEMA = {
-    docs: "https://node-postgres.com",
-    plus: true,
-    friendlyName: "PostgreSQL",
-    type: "Relational",
-    description: "PostgreSQL, also known as Postgres, is a free and open-source relational database management system emphasizing extensibility and SQL compliance.",
-    datasource: {
-        host: {
-            type: types_1.DatasourceFieldType.STRING,
-            default: "localhost",
-            required: true,
-        },
-        port: {
-            type: types_1.DatasourceFieldType.NUMBER,
-            required: true,
-            default: 5432,
-        },
-        database: {
-            type: types_1.DatasourceFieldType.STRING,
-            default: "postgres",
-            required: true,
-        },
-        user: {
-            type: types_1.DatasourceFieldType.STRING,
-            default: "root",
-            required: true,
-        },
-        password: {
-            type: types_1.DatasourceFieldType.PASSWORD,
-            default: "root",
-            required: true,
-        },
-        schema: {
-            type: types_1.DatasourceFieldType.STRING,
-            default: "public",
-            required: true,
-        },
-        ssl: {
-            type: types_1.DatasourceFieldType.BOOLEAN,
-            default: false,
-            required: false,
-        },
-        rejectUnauthorized: {
-            type: types_1.DatasourceFieldType.BOOLEAN,
-            default: false,
-            required: false,
-        },
-        ca: {
-            type: types_1.DatasourceFieldType.LONGFORM,
-            default: false,
-            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,
-        },
-    },
-};
-class PostgresIntegration extends sql_1.default {
-    constructor(config) {
-        super(utils_1.SqlClient.POSTGRES);
-        this.index = 1;
-        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
-  join 
-    information_schema.key_column_usage kc on kc.table_name = tc.table_name 
-    and kc.table_schema = tc.table_schema 
-    and kc.constraint_name = tc.constraint_name
-  where tc.constraint_type = 'PRIMARY KEY';
-  `;
-        this.config = config;
-        let newConfig = Object.assign(Object.assign({}, this.config), { ssl: this.config.ssl
-                ? {
-                    rejectUnauthorized: this.config.rejectUnauthorized,
-                    ca: this.config.ca,
-                }
-                : undefined });
-        this.client = new Client(newConfig);
-        this.open = false;
-    }
-    getBindingIdentifier() {
-        return `$${this.index++}`;
-    }
-    getStringConcat(parts) {
-        return parts.join(" || ");
-    }
-    openConnection() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.client.connect();
-            if (!this.config.schema) {
-                this.config.schema = "public";
-            }
-            this.client.query(`SET search_path TO ${this.config.schema}`);
-            this.COLUMNS_SQL = `select * from information_schema.columns where table_schema = '${this.config.schema}'`;
-            this.open = true;
-        });
-    }
-    closeConnection() {
-        const pg = this;
-        return new Promise((resolve, reject) => {
-            this.client.end((err) => {
-                pg.open = false;
-                if (err) {
-                    reject(err);
-                }
-                else {
-                    resolve();
-                }
-            });
-        });
-    }
-    internalQuery(query, close = true) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.open) {
-                yield this.openConnection();
-            }
-            const client = this.client;
-            this.index = 1;
-            // need to handle a specific issue with json data types in postgres,
-            // new lines inside the JSON data will break it
-            if (query && query.sql) {
-                const matches = query.sql.match(JSON_REGEX);
-                if (matches && matches.length > 0) {
-                    for (let match of matches) {
-                        const escaped = (0, utilities_1.escapeDangerousCharacters)(match);
-                        query.sql = query.sql.replace(match, escaped);
-                    }
-                }
-            }
-            try {
-                return yield client.query(query.sql, query.bindings || []);
-            }
-            catch (err) {
-                yield this.closeConnection();
-                // @ts-ignore
-                throw new Error(err);
-            }
-            finally {
-                if (close) {
-                    yield this.closeConnection();
-                }
-            }
-        });
-    }
-    /**
-     * Fetches the tables from the postgres 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* () {
-            let tableKeys = {};
-            yield this.openConnection();
-            try {
-                const primaryKeysResponse = yield this.client.query(this.PRIMARY_KEYS_SQL);
-                for (let table of primaryKeysResponse.rows) {
-                    const tableName = table.table_name;
-                    if (!tableKeys[tableName]) {
-                        tableKeys[tableName] = [];
-                    }
-                    const key = table.column_name || table.primary_key;
-                    // only add the unique keys
-                    if (key && tableKeys[tableName].indexOf(key) === -1) {
-                        tableKeys[tableName].push(key);
-                    }
-                }
-            }
-            catch (err) {
-                tableKeys = {};
-            }
-            try {
-                const columnsResponse = yield this.client.query(this.COLUMNS_SQL);
-                const tables = {};
-                for (let column of columnsResponse.rows) {
-                    const tableName = column.table_name;
-                    const columnName = column.column_name;
-                    // table key doesn't exist yet
-                    if (!tables[tableName] || !tables[tableName].schema) {
-                        tables[tableName] = {
-                            _id: (0, utils_1.buildExternalTableId)(datasourceId, tableName),
-                            primary: tableKeys[tableName] || [],
-                            name: tableName,
-                            schema: {},
-                        };
-                    }
-                    const identity = !!(column.identity_generation ||
-                        column.identity_start ||
-                        column.identity_increment);
-                    const hasDefault = column.column_default != null;
-                    const hasNextVal = typeof column.column_default === "string" &&
-                        column.column_default.startsWith("nextval");
-                    const isGenerated = column.is_generated && column.is_generated !== "NEVER";
-                    const isAuto = hasNextVal || identity || isGenerated;
-                    const required = column.is_nullable === "NO";
-                    const constraints = {
-                        presence: required && !hasDefault && !isGenerated,
-                    };
-                    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;
-                this.schemaErrors = final.errors;
-            }
-            catch (err) {
-                // @ts-ignore
-                throw new Error(err);
-            }
-            finally {
-                yield this.closeConnection();
-            }
-        });
-    }
-    create(query) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const response = yield this.internalQuery((0, utils_1.getSqlQuery)(query));
-            return 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;
-        });
-    }
-    update(query) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const response = yield this.internalQuery((0, utils_1.getSqlQuery)(query));
-            return 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.length ? response.rows : [{ deleted: true }];
-        });
-    }
-    query(json) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const operation = this._operation(json).toLowerCase();
-            const input = this._query(json);
-            if (Array.isArray(input)) {
-                const responses = [];
-                for (let query of input) {
-                    responses.push(yield this.internalQuery(query, false));
-                }
-                yield this.closeConnection();
-                return responses;
-            }
-            else {
-                const response = yield this.internalQuery(input);
-                return response.rows.length ? response.rows : [{ [operation]: true }];
-            }
-        });
-    }
-}
-exports.default = {
-    schema: SCHEMA,
-    integration: PostgresIntegration,
-};

package/dist/integrations/queries/sql.js

@@ -1,84 +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 });
-exports.interpolateSQL = void 0;
-const string_templates_1 = require("@budibase/string-templates");
-const sdk_1 = __importDefault(require("../../sdk"));
-const CONST_CHAR_REGEX = new RegExp("'[^']*'", "g");
-function interpolateSQL(fields, parameters, integration) {
-    return __awaiter(this, void 0, void 0, function* () {
-        let sql = fields.sql;
-        if (!sql || typeof sql !== "string") {
-            return fields;
-        }
-        const bindings = (0, string_templates_1.findHBSBlocks)(sql);
-        let variables = [], arrays = [];
-        for (let binding of bindings) {
-            // look for array/list operations in the SQL statement, which will need handled later
-            const listRegexMatch = sql.match(new RegExp(`(in|IN|In|iN)( )+[(]?${binding}[)]?`));
-            // check if the variable was used as part of a string concat e.g. 'Hello {{binding}}'
-            // start by finding all the instances of const character strings
-            const charConstMatch = sql.match(CONST_CHAR_REGEX) || [];
-            // now look within them to see if a binding is used
-            const charConstBindingMatch = charConstMatch.find((string) => string.match(new RegExp(`'[^']*${binding}[^']*'`)));
-            if (charConstBindingMatch) {
-                let [part1, part2] = charConstBindingMatch.split(binding);
-                part1 = `'${part1.substring(1)}'`;
-                part2 = `'${part2.substring(0, part2.length - 1)}'`;
-                sql = sql.replace(charConstBindingMatch, integration.getStringConcat([
-                    part1,
-                    integration.getBindingIdentifier(),
-                    part2,
-                ]));
-            }
-            // generate SQL parameterised array
-            else if (listRegexMatch) {
-                arrays.push(binding);
-                // determine the length of the array
-                const value = (yield sdk_1.default.queries.enrichContext([binding], parameters))[0]
-                    .split(",")
-                    .map((val) => val.trim());
-                // build a string like ($1, $2, $3)
-                let replacement = `${Array.apply(null, Array(value.length))
-                    .map(() => integration.getBindingIdentifier())
-                    .join(",")}`;
-                // check if parentheses are needed
-                if (!listRegexMatch[0].includes(`(${binding})`)) {
-                    replacement = `(${replacement})`;
-                }
-                sql = sql.replace(binding, replacement);
-            }
-            else {
-                sql = sql.replace(binding, integration.getBindingIdentifier());
-            }
-            variables.push(binding);
-        }
-        // replicate the knex structure
-        fields.sql = sql;
-        fields.bindings = yield sdk_1.default.queries.enrichContext(variables, parameters);
-        // check for arrays in the data
-        let updated = [];
-        for (let i = 0; i < variables.length; i++) {
-            if (arrays.includes(variables[i])) {
-                updated = updated.concat(fields.bindings[i].split(",").map((val) => val.trim()));
-            }
-            else {
-                updated.push(fields.bindings[i]);
-            }
-        }
-        fields.bindings = updated;
-        return fields;
-    });
-}
-exports.interpolateSQL = interpolateSQL;

package/dist/integrations/redis.js

@@ -1,168 +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 ioredis_1 = __importDefault(require("ioredis"));
-const SCHEMA = {
-    docs: "https://redis.io/docs/",
-    description: "",
-    friendlyName: "Redis",
-    type: "Non-relational",
-    datasource: {
-        host: {
-            type: "string",
-            required: true,
-            default: "localhost",
-        },
-        port: {
-            type: "number",
-            required: true,
-            default: 6379,
-        },
-        username: {
-            type: "string",
-            required: false,
-        },
-        password: {
-            type: "password",
-            required: false,
-        },
-        db: {
-            type: "number",
-            required: false,
-            display: "DB",
-            default: 0,
-        },
-    },
-    query: {
-        create: {
-            type: types_1.QueryType.FIELDS,
-            fields: {
-                key: {
-                    type: types_1.DatasourceFieldType.STRING,
-                    required: true,
-                },
-                value: {
-                    type: types_1.DatasourceFieldType.STRING,
-                    required: true,
-                },
-                ttl: {
-                    type: types_1.DatasourceFieldType.NUMBER,
-                },
-            },
-        },
-        read: {
-            readable: true,
-            type: types_1.QueryType.FIELDS,
-            fields: {
-                key: {
-                    type: types_1.DatasourceFieldType.STRING,
-                    required: true,
-                },
-            },
-        },
-        delete: {
-            type: types_1.QueryType.FIELDS,
-            fields: {
-                key: {
-                    type: types_1.DatasourceFieldType.STRING,
-                    required: true,
-                },
-            },
-        },
-        command: {
-            readable: true,
-            displayName: "Redis Command",
-            type: types_1.QueryType.JSON,
-        },
-    },
-};
-class RedisIntegration {
-    constructor(config) {
-        this.config = config;
-        this.client = new ioredis_1.default({
-            host: this.config.host,
-            port: this.config.port,
-            username: this.config.username,
-            password: this.config.password,
-            db: this.config.db,
-        });
-    }
-    disconnect() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.client.quit();
-        });
-    }
-    redisContext(query) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                return yield query();
-            }
-            catch (err) {
-                throw new Error(`Redis error: ${err}`);
-            }
-            finally {
-                yield this.disconnect();
-            }
-        });
-    }
-    create(query) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.redisContext(() => __awaiter(this, void 0, void 0, function* () {
-                const response = yield this.client.set(query.key, query.value);
-                if (query.ttl) {
-                    yield this.client.expire(query.key, query.ttl);
-                }
-                return response;
-            }));
-        });
-    }
-    read(query) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.redisContext(() => __awaiter(this, void 0, void 0, function* () {
-                return yield this.client.get(query.key);
-            }));
-        });
-    }
-    delete(query) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.redisContext(() => __awaiter(this, void 0, void 0, function* () {
-                return yield this.client.del(query.key);
-            }));
-        });
-    }
-    command(query) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.redisContext(() => __awaiter(this, void 0, void 0, function* () {
-                // commands split line by line
-                const commands = query.json.trim().split("\n");
-                let pipelineCommands = [];
-                // process each command separately
-                for (let command of commands) {
-                    const tokenised = command.trim().split(" ");
-                    // Pipeline only accepts lower case commands
-                    tokenised[0] = tokenised[0].toLowerCase();
-                    pipelineCommands.push(tokenised);
-                }
-                const pipeline = this.client.pipeline(pipelineCommands);
-                const result = yield pipeline.exec();
-                return result.map((output) => output[1]);
-            }));
-        });
-    }
-}
-exports.default = {
-    schema: SCHEMA,
-    integration: RedisIntegration,
-};