@budibase/server 1.3.14 → 1.3.15-alpha.2

package/dist/integrations/index.js

@@ -1,65 +1,107 @@
 "use strict";
-const postgres = require("./postgres");
-const dynamodb = require("./dynamodb");
-const mongodb = require("./mongodb");
-const elasticsearch = require("./elasticsearch");
-const couchdb = require("./couchdb");
-const sqlServer = require("./microsoftSqlServer");
-const s3 = require("./s3");
-const airtable = require("./airtable");
-const mysql = require("./mysql");
-const arangodb = require("./arangodb");
-const rest = require("./rest");
-const googlesheets = require("./googlesheets");
-const firebase = require("./firebase");
-const redis = require("./redis");
-const snowflake = require("./snowflake");
-const { SourceName } = require("@budibase/types");
+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 postgres_1 = __importDefault(require("./postgres"));
+const dynamodb_1 = __importDefault(require("./dynamodb"));
+const mongodb_1 = __importDefault(require("./mongodb"));
+const elasticsearch_1 = __importDefault(require("./elasticsearch"));
+const couchdb_1 = __importDefault(require("./couchdb"));
+const microsoftSqlServer_1 = __importDefault(require("./microsoftSqlServer"));
+const s3_1 = __importDefault(require("./s3"));
+const airtable_1 = __importDefault(require("./airtable"));
+const mysql_1 = __importDefault(require("./mysql"));
+const arangodb_1 = __importDefault(require("./arangodb"));
+const rest_1 = __importDefault(require("./rest"));
+const googlesheets_1 = __importDefault(require("./googlesheets"));
+const firebase_1 = __importDefault(require("./firebase"));
+const redis_1 = __importDefault(require("./redis"));
+const snowflake_1 = __importDefault(require("./snowflake"));
+const plugin_1 = require("../api/controllers/plugin");
+const types_1 = require("@budibase/types");
+const fileSystem_1 = require("../utilities/fileSystem");
 const environment = require("../environment");
+const { cloneDeep } = require("lodash");
 const DEFINITIONS = {
-    [SourceName.POSTGRES]: postgres.schema,
-    [SourceName.DYNAMODB]: dynamodb.schema,
-    [SourceName.MONGODB]: mongodb.schema,
-    [SourceName.ELASTICSEARCH]: elasticsearch.schema,
-    [SourceName.COUCHDB]: couchdb.schema,
-    [SourceName.SQL_SERVER]: sqlServer.schema,
-    [SourceName.S3]: s3.schema,
-    [SourceName.AIRTABLE]: airtable.schema,
-    [SourceName.MYSQL]: mysql.schema,
-    [SourceName.ARANGODB]: arangodb.schema,
-    [SourceName.REST]: rest.schema,
-    [SourceName.FIRESTORE]: firebase.schema,
-    [SourceName.REDIS]: redis.schema,
-    [SourceName.SNOWFLAKE]: snowflake.schema,
+    [types_1.SourceName.POSTGRES]: postgres_1.default.schema,
+    [types_1.SourceName.DYNAMODB]: dynamodb_1.default.schema,
+    [types_1.SourceName.MONGODB]: mongodb_1.default.schema,
+    [types_1.SourceName.ELASTICSEARCH]: elasticsearch_1.default.schema,
+    [types_1.SourceName.COUCHDB]: couchdb_1.default.schema,
+    [types_1.SourceName.SQL_SERVER]: microsoftSqlServer_1.default.schema,
+    [types_1.SourceName.S3]: s3_1.default.schema,
+    [types_1.SourceName.AIRTABLE]: airtable_1.default.schema,
+    [types_1.SourceName.MYSQL]: mysql_1.default.schema,
+    [types_1.SourceName.ARANGODB]: arangodb_1.default.schema,
+    [types_1.SourceName.REST]: rest_1.default.schema,
+    [types_1.SourceName.FIRESTORE]: firebase_1.default.schema,
+    [types_1.SourceName.REDIS]: redis_1.default.schema,
+    [types_1.SourceName.SNOWFLAKE]: snowflake_1.default.schema,
 };
 const INTEGRATIONS = {
-    [SourceName.POSTGRES]: postgres.integration,
-    [SourceName.DYNAMODB]: dynamodb.integration,
-    [SourceName.MONGODB]: mongodb.integration,
-    [SourceName.ELASTICSEARCH]: elasticsearch.integration,
-    [SourceName.COUCHDB]: couchdb.integration,
-    [SourceName.SQL_SERVER]: sqlServer.integration,
-    [SourceName.S3]: s3.integration,
-    [SourceName.AIRTABLE]: airtable.integration,
-    [SourceName.MYSQL]: mysql.integration,
-    [SourceName.ARANGODB]: arangodb.integration,
-    [SourceName.REST]: rest.integration,
-    [SourceName.FIRESTORE]: firebase.integration,
-    [SourceName.GOOGLE_SHEETS]: googlesheets.integration,
-    [SourceName.REDIS]: redis.integration,
-    [SourceName.FIREBASE]: firebase.integration,
-    [SourceName.SNOWFLAKE]: snowflake.integration,
+    [types_1.SourceName.POSTGRES]: postgres_1.default.integration,
+    [types_1.SourceName.DYNAMODB]: dynamodb_1.default.integration,
+    [types_1.SourceName.MONGODB]: mongodb_1.default.integration,
+    [types_1.SourceName.ELASTICSEARCH]: elasticsearch_1.default.integration,
+    [types_1.SourceName.COUCHDB]: couchdb_1.default.integration,
+    [types_1.SourceName.SQL_SERVER]: microsoftSqlServer_1.default.integration,
+    [types_1.SourceName.S3]: s3_1.default.integration,
+    [types_1.SourceName.AIRTABLE]: airtable_1.default.integration,
+    [types_1.SourceName.MYSQL]: mysql_1.default.integration,
+    [types_1.SourceName.ARANGODB]: arangodb_1.default.integration,
+    [types_1.SourceName.REST]: rest_1.default.integration,
+    [types_1.SourceName.FIRESTORE]: firebase_1.default.integration,
+    [types_1.SourceName.GOOGLE_SHEETS]: googlesheets_1.default.integration,
+    [types_1.SourceName.REDIS]: redis_1.default.integration,
+    [types_1.SourceName.FIRESTORE]: firebase_1.default.integration,
+    [types_1.SourceName.SNOWFLAKE]: snowflake_1.default.integration,
 };
 // optionally add oracle integration if the oracle binary can be installed
 if (process.arch && !process.arch.startsWith("arm")) {
     const oracle = require("./oracle");
-    DEFINITIONS[SourceName.ORACLE] = oracle.schema;
-    INTEGRATIONS[SourceName.ORACLE] = oracle.integration;
+    DEFINITIONS[types_1.SourceName.ORACLE] = oracle.schema;
+    INTEGRATIONS[types_1.SourceName.ORACLE] = oracle.integration;
 }
 if (environment.SELF_HOSTED) {
-    DEFINITIONS[SourceName.GOOGLE_SHEETS] = googlesheets.schema;
+    DEFINITIONS[types_1.SourceName.GOOGLE_SHEETS] = googlesheets_1.default.schema;
 }
 module.exports = {
-    definitions: DEFINITIONS,
-    integrations: INTEGRATIONS,
+    getDefinitions: () => __awaiter(void 0, void 0, void 0, function* () {
+        const pluginSchemas = {};
+        if (environment.SELF_HOSTED) {
+            const plugins = yield (0, plugin_1.getPlugins)(types_1.PluginType.DATASOURCE);
+            // extract the actual schema from each custom
+            for (let plugin of plugins) {
+                const sourceId = plugin.name;
+                pluginSchemas[sourceId] = Object.assign(Object.assign({}, plugin.schema["schema"]), { custom: true });
+            }
+        }
+        return Object.assign(Object.assign({}, cloneDeep(DEFINITIONS)), pluginSchemas);
+    }),
+    getIntegration: (integration) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a;
+        if (INTEGRATIONS[integration]) {
+            return INTEGRATIONS[integration];
+        }
+        if (environment.SELF_HOSTED) {
+            const plugins = yield (0, plugin_1.getPlugins)(types_1.PluginType.DATASOURCE);
+            for (let plugin of plugins) {
+                if (plugin.name === integration) {
+                    // need to use commonJS require due to its dynamic runtime nature
+                    return (0, fileSystem_1.getDatasourcePlugin)(plugin.name, plugin.jsUrl, (_a = plugin.schema) === null || _a === void 0 ? void 0 : _a.hash);
+                }
+            }
+        }
+        throw new Error("No datasource implementation found.");
+    }),
 };

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,
+};