@budibase/server 1.3.21 → 1.3.22-alpha.1

package/dist/integrations/postgres.js

@@ -15,284 +15,281 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const types_1 = require("@budibase/types");
 const utils_1 = require("./utils");
 const sql_1 = __importDefault(require("./base/sql"));
-var PostgresModule;
-(function (PostgresModule) {
-    const { Client, types } = require("pg");
-    const { escapeDangerousCharacters } = require("../utilities");
-    // Return "date" and "timestamp" types as plain strings.
-    // This lets us reference the original stored timezone.
-    // types is undefined when running in a test env for some reason.
-    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,
-            },
+const { Client, types } = require("pg");
+const { escapeDangerousCharacters } = require("../utilities");
+// Return "date" and "timestamp" types as plain strings.
+// This lets us reference the original stored timezone.
+// types is undefined when running in a test env for some reason.
+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,
         },
-        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,
-            },
+        port: {
+            type: types_1.DatasourceFieldType.NUMBER,
+            required: true,
+            default: 5432,
         },
-    };
-    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 = escapeDangerousCharacters(match);
-                            query.sql = query.sql.replace(match, escaped);
-                        }
-                    }
-                }
-                try {
-                    return yield client.query(query.sql, query.bindings || []);
+        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,
                 }
-                catch (err) {
-                    yield this.closeConnection();
-                    // @ts-ignore
-                    throw new Error(err);
+                : 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);
                 }
-                finally {
-                    if (close) {
-                        yield this.closeConnection();
-                    }
+                else {
+                    resolve();
                 }
             });
-        }
-        /**
-         * 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 = {};
+        });
+    }
+    internalQuery(query, close = true) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.open) {
                 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);
-                        }
+            }
+            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 = escapeDangerousCharacters(match);
+                        query.sql = query.sql.replace(match, escaped);
                     }
                 }
-                catch (err) {
-                    tableKeys = {};
+            }
+            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();
                 }
-                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 = typeof column.column_default === "string" &&
-                            column.column_default.startsWith("nextval");
-                        const isGenerated = column.is_generated && column.is_generated !== "NEVER";
-                        const isAuto = hasDefault || identity || isGenerated;
-                        tables[tableName].schema[columnName] = Object.assign(Object.assign({ autocolumn: isAuto, name: columnName }, (0, utils_1.convertSqlType)(column.data_type)), { externalType: column.data_type });
+            }
+        });
+    }
+    /**
+     * 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);
                     }
-                    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));
+            }
+            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: {},
+                        };
                     }
-                    yield this.closeConnection();
-                    return responses;
+                    const identity = !!(column.identity_generation ||
+                        column.identity_start ||
+                        column.identity_increment);
+                    const hasDefault = typeof column.column_default === "string" &&
+                        column.column_default.startsWith("nextval");
+                    const isGenerated = column.is_generated && column.is_generated !== "NEVER";
+                    const isAuto = hasDefault || identity || isGenerated;
+                    tables[tableName].schema[columnName] = Object.assign(Object.assign({ autocolumn: isAuto, name: columnName }, (0, utils_1.convertSqlType)(column.data_type)), { externalType: column.data_type });
                 }
-                else {
-                    const response = yield this.internalQuery(input);
-                    return response.rows.length ? response.rows : [{ [operation]: true }];
+                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 }];
+            }
+        });
     }
-    module.exports = {
-        schema: SCHEMA,
-        integration: PostgresIntegration,
-    };
-})(PostgresModule || (PostgresModule = {}));
+}
+exports.default = {
+    schema: SCHEMA,
+    integration: PostgresIntegration,
+};