@budibase/server 1.3.21 → 1.3.22-alpha.1

package/dist/integrations/microsoftSqlServer.js

@@ -15,254 +15,251 @@ 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 MSSQLModule;
-(function (MSSQLModule) {
-    const sqlServer = require("mssql");
-    const DEFAULT_SCHEMA = "dbo";
-    const SCHEMA = {
-        docs: "https://github.com/tediousjs/node-mssql",
-        plus: true,
-        description: "Microsoft SQL Server is a relational database management system developed by Microsoft. ",
-        friendlyName: "MS SQL Server",
-        type: "Relational",
-        datasource: {
-            user: {
-                type: types_1.DatasourceFieldType.STRING,
-                required: true,
-                default: "localhost",
-            },
-            password: {
-                type: types_1.DatasourceFieldType.PASSWORD,
-                required: true,
-            },
-            server: {
-                type: types_1.DatasourceFieldType.STRING,
-                default: "localhost",
-            },
-            port: {
-                type: types_1.DatasourceFieldType.NUMBER,
-                required: false,
-                default: 1433,
-            },
-            database: {
-                type: types_1.DatasourceFieldType.STRING,
-                default: "root",
-            },
-            schema: {
-                type: types_1.DatasourceFieldType.STRING,
-                default: DEFAULT_SCHEMA,
-            },
-            encrypt: {
-                type: types_1.DatasourceFieldType.BOOLEAN,
-                default: true,
-            },
+const sqlServer = require("mssql");
+const DEFAULT_SCHEMA = "dbo";
+const SCHEMA = {
+    docs: "https://github.com/tediousjs/node-mssql",
+    plus: true,
+    description: "Microsoft SQL Server is a relational database management system developed by Microsoft. ",
+    friendlyName: "MS SQL Server",
+    type: "Relational",
+    datasource: {
+        user: {
+            type: types_1.DatasourceFieldType.STRING,
+            required: true,
+            default: "localhost",
         },
-        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,
-            },
+        password: {
+            type: types_1.DatasourceFieldType.PASSWORD,
+            required: true,
         },
-    };
-    class SqlServerIntegration extends sql_1.default {
-        constructor(config) {
-            super(utils_1.SqlClient.MS_SQL);
-            this.index = 0;
-            this.tables = {};
-            this.schemaErrors = {};
-            this.MASTER_TABLES = [
-                "spt_fallback_db",
-                "spt_fallback_dev",
-                "spt_fallback_usg",
-                "spt_monitor",
-                "MSreplication_options",
-            ];
-            this.TABLES_SQL = "SELECT * FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_TYPE='BASE TABLE'";
-            this.config = config;
-            const clientCfg = Object.assign(Object.assign({}, this.config), { options: {
-                    encrypt: this.config.encrypt,
-                    enableArithAbort: true,
-                } });
-            delete clientCfg.encrypt;
-            if (!this.pool) {
-                this.pool = new sqlServer.ConnectionPool(clientCfg);
-            }
-        }
-        getBindingIdentifier() {
-            return `@p${this.index++}`;
-        }
-        getStringConcat(parts) {
-            return `concat(${parts.join(", ")})`;
-        }
-        connect() {
-            return __awaiter(this, void 0, void 0, function* () {
-                try {
-                    this.client = yield this.pool.connect();
-                }
-                catch (err) {
-                    // @ts-ignore
-                    throw new Error(err);
-                }
-            });
+        server: {
+            type: types_1.DatasourceFieldType.STRING,
+            default: "localhost",
+        },
+        port: {
+            type: types_1.DatasourceFieldType.NUMBER,
+            required: false,
+            default: 1433,
+        },
+        database: {
+            type: types_1.DatasourceFieldType.STRING,
+            default: "root",
+        },
+        schema: {
+            type: types_1.DatasourceFieldType.STRING,
+            default: DEFAULT_SCHEMA,
+        },
+        encrypt: {
+            type: types_1.DatasourceFieldType.BOOLEAN,
+            default: 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,
+        },
+    },
+};
+class SqlServerIntegration extends sql_1.default {
+    constructor(config) {
+        super(utils_1.SqlClient.MS_SQL);
+        this.index = 0;
+        this.tables = {};
+        this.schemaErrors = {};
+        this.MASTER_TABLES = [
+            "spt_fallback_db",
+            "spt_fallback_dev",
+            "spt_fallback_usg",
+            "spt_monitor",
+            "MSreplication_options",
+        ];
+        this.TABLES_SQL = "SELECT * FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_TYPE='BASE TABLE'";
+        this.config = config;
+        const clientCfg = Object.assign(Object.assign({}, this.config), { options: {
+                encrypt: this.config.encrypt,
+                enableArithAbort: true,
+            } });
+        delete clientCfg.encrypt;
+        if (!this.pool) {
+            this.pool = new sqlServer.ConnectionPool(clientCfg);
         }
-        internalQuery(query, operation = undefined) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const client = this.client;
-                const request = client.request();
-                this.index = 0;
-                try {
-                    if (Array.isArray(query.bindings)) {
-                        let count = 0;
-                        for (let binding of query.bindings) {
-                            request.input(`p${count++}`, binding);
-                        }
+    }
+    getBindingIdentifier() {
+        return `@p${this.index++}`;
+    }
+    getStringConcat(parts) {
+        return `concat(${parts.join(", ")})`;
+    }
+    connect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                this.client = yield this.pool.connect();
+            }
+            catch (err) {
+                // @ts-ignore
+                throw new Error(err);
+            }
+        });
+    }
+    internalQuery(query, operation = undefined) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const client = this.client;
+            const request = client.request();
+            this.index = 0;
+            try {
+                if (Array.isArray(query.bindings)) {
+                    let count = 0;
+                    for (let binding of query.bindings) {
+                        request.input(`p${count++}`, binding);
                     }
-                    // this is a hack to get the inserted ID back,
-                    //  no way to do this with Knex nicely
-                    const sql = operation === types_1.Operation.CREATE
-                        ? `${query.sql}; SELECT SCOPE_IDENTITY() AS id;`
-                        : query.sql;
-                    return yield request.query(sql);
-                }
-                catch (err) {
-                    // @ts-ignore
-                    throw new Error(err);
-                }
-            });
-        }
-        getDefinitionSQL(tableName) {
-            return `select *
-              from INFORMATION_SCHEMA.COLUMNS
-              where TABLE_NAME='${tableName}'`;
-        }
-        getConstraintsSQL(tableName) {
-            return `SELECT * FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS AS TC 
-              INNER JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE AS KU
-                ON TC.CONSTRAINT_TYPE = 'PRIMARY KEY' 
-                AND TC.CONSTRAINT_NAME = KU.CONSTRAINT_NAME 
-                AND KU.table_name='${tableName}'
-              ORDER BY 
-                KU.TABLE_NAME,
-                KU.ORDINAL_POSITION;`;
-        }
-        getAutoColumnsSQL(tableName) {
-            return `SELECT 
-              COLUMNPROPERTY(OBJECT_ID(TABLE_SCHEMA+'.'+TABLE_NAME),COLUMN_NAME,'IsComputed') 
-                AS IS_COMPUTED,
-              COLUMNPROPERTY(object_id(TABLE_SCHEMA+'.'+TABLE_NAME), COLUMN_NAME, 'IsIdentity')
-                AS IS_IDENTITY,
-              *
-              FROM INFORMATION_SCHEMA.COLUMNS
-              WHERE TABLE_NAME='${tableName}'`;
-        }
-        runSQL(sql) {
-            return __awaiter(this, void 0, void 0, function* () {
-                return (yield this.internalQuery((0, utils_1.getSqlQuery)(sql))).recordset;
-            });
-        }
-        /**
-         * Fetches the tables from the sql server database 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* () {
-                yield this.connect();
-                let tableInfo = yield this.runSQL(this.TABLES_SQL);
-                if (tableInfo == null || !Array.isArray(tableInfo)) {
-                    throw "Unable to get list of tables in database";
                 }
-                const schema = this.config.schema || DEFAULT_SCHEMA;
-                const tableNames = tableInfo
-                    .filter((record) => record.TABLE_SCHEMA === schema)
-                    .map((record) => record.TABLE_NAME)
-                    .filter((name) => this.MASTER_TABLES.indexOf(name) === -1);
-                const tables = {};
-                for (let tableName of tableNames) {
-                    // get the column definition (type)
-                    const definition = yield this.runSQL(this.getDefinitionSQL(tableName));
-                    // find primary key constraints
-                    const constraints = yield this.runSQL(this.getConstraintsSQL(tableName));
-                    // find the computed and identity columns (auto columns)
-                    const columns = yield this.runSQL(this.getAutoColumnsSQL(tableName));
-                    const primaryKeys = constraints
-                        .filter((constraint) => constraint.CONSTRAINT_TYPE === "PRIMARY KEY")
-                        .map((constraint) => constraint.COLUMN_NAME);
-                    const autoColumns = columns
-                        .filter((col) => col.IS_COMPUTED || col.IS_IDENTITY)
-                        .map((col) => col.COLUMN_NAME);
-                    let schema = {};
-                    for (let def of definition) {
-                        const name = def.COLUMN_NAME;
-                        if (typeof name !== "string") {
-                            continue;
-                        }
-                        schema[name] = Object.assign(Object.assign({ autocolumn: !!autoColumns.find((col) => col === name), name: name }, (0, utils_1.convertSqlType)(def.DATA_TYPE)), { externalType: def.DATA_TYPE });
+                // this is a hack to get the inserted ID back,
+                //  no way to do this with Knex nicely
+                const sql = operation === types_1.Operation.CREATE
+                    ? `${query.sql}; SELECT SCOPE_IDENTITY() AS id;`
+                    : query.sql;
+                return yield request.query(sql);
+            }
+            catch (err) {
+                // @ts-ignore
+                throw new Error(err);
+            }
+        });
+    }
+    getDefinitionSQL(tableName) {
+        return `select *
+            from INFORMATION_SCHEMA.COLUMNS
+            where TABLE_NAME='${tableName}'`;
+    }
+    getConstraintsSQL(tableName) {
+        return `SELECT * FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS AS TC 
+            INNER JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE AS KU
+              ON TC.CONSTRAINT_TYPE = 'PRIMARY KEY' 
+              AND TC.CONSTRAINT_NAME = KU.CONSTRAINT_NAME 
+              AND KU.table_name='${tableName}'
+            ORDER BY 
+              KU.TABLE_NAME,
+              KU.ORDINAL_POSITION;`;
+    }
+    getAutoColumnsSQL(tableName) {
+        return `SELECT 
+            COLUMNPROPERTY(OBJECT_ID(TABLE_SCHEMA+'.'+TABLE_NAME),COLUMN_NAME,'IsComputed') 
+              AS IS_COMPUTED,
+            COLUMNPROPERTY(object_id(TABLE_SCHEMA+'.'+TABLE_NAME), COLUMN_NAME, 'IsIdentity')
+              AS IS_IDENTITY,
+            *
+            FROM INFORMATION_SCHEMA.COLUMNS
+            WHERE TABLE_NAME='${tableName}'`;
+    }
+    runSQL(sql) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.internalQuery((0, utils_1.getSqlQuery)(sql))).recordset;
+        });
+    }
+    /**
+     * Fetches the tables from the sql server database 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* () {
+            yield this.connect();
+            let tableInfo = yield this.runSQL(this.TABLES_SQL);
+            if (tableInfo == null || !Array.isArray(tableInfo)) {
+                throw "Unable to get list of tables in database";
+            }
+            const schema = this.config.schema || DEFAULT_SCHEMA;
+            const tableNames = tableInfo
+                .filter((record) => record.TABLE_SCHEMA === schema)
+                .map((record) => record.TABLE_NAME)
+                .filter((name) => this.MASTER_TABLES.indexOf(name) === -1);
+            const tables = {};
+            for (let tableName of tableNames) {
+                // get the column definition (type)
+                const definition = yield this.runSQL(this.getDefinitionSQL(tableName));
+                // find primary key constraints
+                const constraints = yield this.runSQL(this.getConstraintsSQL(tableName));
+                // find the computed and identity columns (auto columns)
+                const columns = yield this.runSQL(this.getAutoColumnsSQL(tableName));
+                const primaryKeys = constraints
+                    .filter((constraint) => constraint.CONSTRAINT_TYPE === "PRIMARY KEY")
+                    .map((constraint) => constraint.COLUMN_NAME);
+                const autoColumns = columns
+                    .filter((col) => col.IS_COMPUTED || col.IS_IDENTITY)
+                    .map((col) => col.COLUMN_NAME);
+                let schema = {};
+                for (let def of definition) {
+                    const name = def.COLUMN_NAME;
+                    if (typeof name !== "string") {
+                        continue;
                     }
-                    tables[tableName] = {
-                        _id: (0, utils_1.buildExternalTableId)(datasourceId, tableName),
-                        primary: primaryKeys,
-                        name: tableName,
-                        schema,
-                    };
+                    schema[name] = Object.assign(Object.assign({ autocolumn: !!autoColumns.find((col) => col === name), name: name }, (0, utils_1.convertSqlType)(def.DATA_TYPE)), { externalType: def.DATA_TYPE });
                 }
-                const final = (0, utils_1.finaliseExternalTables)(tables, entities);
-                this.tables = final.tables;
-                this.schemaErrors = final.errors;
-            });
-        }
-        read(query) {
-            return __awaiter(this, void 0, void 0, function* () {
-                yield this.connect();
-                const response = yield this.internalQuery((0, utils_1.getSqlQuery)(query));
-                return response.recordset;
-            });
-        }
-        create(query) {
-            return __awaiter(this, void 0, void 0, function* () {
-                yield this.connect();
-                const response = yield this.internalQuery((0, utils_1.getSqlQuery)(query));
-                return response.recordset || [{ created: true }];
-            });
-        }
-        update(query) {
-            return __awaiter(this, void 0, void 0, function* () {
-                yield this.connect();
-                const response = yield this.internalQuery((0, utils_1.getSqlQuery)(query));
-                return response.recordset || [{ updated: true }];
-            });
-        }
-        delete(query) {
-            return __awaiter(this, void 0, void 0, function* () {
-                yield this.connect();
-                const response = yield this.internalQuery((0, utils_1.getSqlQuery)(query));
-                return response.recordset || [{ deleted: true }];
-            });
-        }
-        query(json) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const schema = this.config.schema;
-                yield this.connect();
-                if (schema && schema !== DEFAULT_SCHEMA && (json === null || json === void 0 ? void 0 : json.endpoint)) {
-                    json.endpoint.schema = schema;
-                }
-                const operation = this._operation(json);
-                const queryFn = (query, op) => this.internalQuery(query, op);
-                const processFn = (result) => result.recordset ? result.recordset : [{ [operation]: true }];
-                return this.queryWithReturning(json, queryFn, processFn);
-            });
-        }
+                tables[tableName] = {
+                    _id: (0, utils_1.buildExternalTableId)(datasourceId, tableName),
+                    primary: primaryKeys,
+                    name: tableName,
+                    schema,
+                };
+            }
+            const final = (0, utils_1.finaliseExternalTables)(tables, entities);
+            this.tables = final.tables;
+            this.schemaErrors = final.errors;
+        });
+    }
+    read(query) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.connect();
+            const response = yield this.internalQuery((0, utils_1.getSqlQuery)(query));
+            return response.recordset;
+        });
     }
-    module.exports = {
-        schema: SCHEMA,
-        integration: SqlServerIntegration,
-    };
-})(MSSQLModule || (MSSQLModule = {}));
+    create(query) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.connect();
+            const response = yield this.internalQuery((0, utils_1.getSqlQuery)(query));
+            return response.recordset || [{ created: true }];
+        });
+    }
+    update(query) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.connect();
+            const response = yield this.internalQuery((0, utils_1.getSqlQuery)(query));
+            return response.recordset || [{ updated: true }];
+        });
+    }
+    delete(query) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.connect();
+            const response = yield this.internalQuery((0, utils_1.getSqlQuery)(query));
+            return response.recordset || [{ deleted: true }];
+        });
+    }
+    query(json) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const schema = this.config.schema;
+            yield this.connect();
+            if (schema && schema !== DEFAULT_SCHEMA && (json === null || json === void 0 ? void 0 : json.endpoint)) {
+                json.endpoint.schema = schema;
+            }
+            const operation = this._operation(json);
+            const queryFn = (query, op) => this.internalQuery(query, op);
+            const processFn = (result) => result.recordset ? result.recordset : [{ [operation]: true }];
+            return this.queryWithReturning(json, queryFn, processFn);
+        });
+    }
+}
+exports.default = {
+    schema: SCHEMA,
+    integration: SqlServerIntegration,
+};