@budibase/server 1.3.21-alpha.1 → 1.3.21

package/dist/integrations/mongodb.js

@@ -11,274 +11,277 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 const types_1 = require("@budibase/types");
 const mongodb_1 = require("mongodb");
-const SCHEMA = {
-    docs: "https://github.com/mongodb/node-mongodb-native",
-    friendlyName: "MongoDB",
-    type: "Non-relational",
-    description: "MongoDB is a general purpose, document-based, distributed database built for modern application developers and for the cloud era.",
-    datasource: {
-        connectionString: {
-            type: types_1.DatasourceFieldType.STRING,
-            required: true,
-            default: "mongodb://localhost:27017",
-        },
-        db: {
-            type: types_1.DatasourceFieldType.STRING,
-            required: true,
-        },
-    },
-    query: {
-        create: {
-            type: types_1.QueryType.JSON,
-        },
-        read: {
-            type: types_1.QueryType.JSON,
-        },
-        update: {
-            type: types_1.QueryType.JSON,
-        },
-        delete: {
-            type: types_1.QueryType.JSON,
+var MongoDBModule;
+(function (MongoDBModule) {
+    const SCHEMA = {
+        docs: "https://github.com/mongodb/node-mongodb-native",
+        friendlyName: "MongoDB",
+        type: "Non-relational",
+        description: "MongoDB is a general purpose, document-based, distributed database built for modern application developers and for the cloud era.",
+        datasource: {
+            connectionString: {
+                type: types_1.DatasourceFieldType.STRING,
+                required: true,
+                default: "mongodb://localhost:27017",
+            },
+            db: {
+                type: types_1.DatasourceFieldType.STRING,
+                required: true,
+            },
         },
-    },
-    extra: {
-        collection: {
-            displayName: "Collection",
-            type: types_1.DatasourceFieldType.STRING,
-            required: true,
+        query: {
+            create: {
+                type: types_1.QueryType.JSON,
+            },
+            read: {
+                type: types_1.QueryType.JSON,
+            },
+            update: {
+                type: types_1.QueryType.JSON,
+            },
+            delete: {
+                type: types_1.QueryType.JSON,
+            },
         },
-        actionTypes: {
-            displayName: "Action Types",
-            type: types_1.DatasourceFieldType.LIST,
-            required: true,
-            data: {
-                read: ["find", "findOne", "findOneAndUpdate", "count", "distinct"],
-                create: ["insertOne", "insertMany"],
-                update: ["updateOne", "updateMany"],
-                delete: ["deleteOne", "deleteMany"],
+        extra: {
+            collection: {
+                displayName: "Collection",
+                type: types_1.DatasourceFieldType.STRING,
+                required: true,
+            },
+            actionTypes: {
+                displayName: "Action Types",
+                type: types_1.DatasourceFieldType.LIST,
+                required: true,
+                data: {
+                    read: ["find", "findOne", "findOneAndUpdate", "count", "distinct"],
+                    create: ["insertOne", "insertMany"],
+                    update: ["updateOne", "updateMany"],
+                    delete: ["deleteOne", "deleteMany"],
+                },
             },
         },
-    },
-};
-class MongoIntegration {
-    constructor(config) {
-        this.config = config;
-        this.client = new mongodb_1.MongoClient(config.connectionString);
-    }
-    connect() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.client.connect();
-        });
-    }
-    createObjectIds(json) {
-        const self = this;
-        function interpolateObjectIds(json) {
-            var _a;
-            for (let field of Object.keys(json)) {
-                if (json[field] instanceof Object) {
-                    json[field] = self.createObjectIds(json[field]);
-                }
-                if (typeof json[field] === "string" &&
-                    json[field].toLowerCase().startsWith("objectid")) {
-                    const id = (_a = json[field].match(/(?<=objectid\(['"]).*(?=['"]\))/gi)) === null || _a === void 0 ? void 0 : _a[0];
-                    if (id) {
-                        json[field] = mongodb_1.ObjectID.createFromHexString(id);
+    };
+    class MongoIntegration {
+        constructor(config) {
+            this.config = config;
+            this.client = new mongodb_1.MongoClient(config.connectionString);
+        }
+        connect() {
+            return __awaiter(this, void 0, void 0, function* () {
+                return this.client.connect();
+            });
+        }
+        createObjectIds(json) {
+            const self = this;
+            function interpolateObjectIds(json) {
+                var _a;
+                for (let field of Object.keys(json)) {
+                    if (json[field] instanceof Object) {
+                        json[field] = self.createObjectIds(json[field]);
+                    }
+                    if (typeof json[field] === "string" &&
+                        json[field].toLowerCase().startsWith("objectid")) {
+                        const id = (_a = json[field].match(/(?<=objectid\(['"]).*(?=['"]\))/gi)) === null || _a === void 0 ? void 0 : _a[0];
+                        if (id) {
+                            json[field] = mongodb_1.ObjectID.createFromHexString(id);
+                        }
                     }
                 }
+                return json;
             }
-            return json;
-        }
-        if (Array.isArray(json)) {
-            for (let i = 0; i < json.length; i++) {
-                json[i] = interpolateObjectIds(json[i]);
+            if (Array.isArray(json)) {
+                for (let i = 0; i < json.length; i++) {
+                    json[i] = interpolateObjectIds(json[i]);
+                }
+                return json;
             }
-            return json;
+            return interpolateObjectIds(json);
         }
-        return interpolateObjectIds(json);
-    }
-    parseQueryParams(params, mode) {
-        var _a, _b, _c;
-        let queryParams = [];
-        let openCount = 0;
-        let inQuotes = false;
-        let i = 0;
-        let startIndex = 0;
-        for (let c of params) {
-            if (c === '"' && i > 0 && params[i - 1] !== "\\") {
-                inQuotes = !inQuotes;
-            }
-            if (c === "{" && !inQuotes) {
-                openCount++;
-                if (openCount === 1) {
-                    startIndex = i;
+        parseQueryParams(params, mode) {
+            var _a, _b, _c;
+            let queryParams = [];
+            let openCount = 0;
+            let inQuotes = false;
+            let i = 0;
+            let startIndex = 0;
+            for (let c of params) {
+                if (c === '"' && i > 0 && params[i - 1] !== "\\") {
+                    inQuotes = !inQuotes;
                 }
-            }
-            else if (c === "}" && !inQuotes) {
-                if (openCount === 1) {
-                    queryParams.push(JSON.parse(params.substring(startIndex, i + 1)));
+                if (c === "{" && !inQuotes) {
+                    openCount++;
+                    if (openCount === 1) {
+                        startIndex = i;
+                    }
+                }
+                else if (c === "}" && !inQuotes) {
+                    if (openCount === 1) {
+                        queryParams.push(JSON.parse(params.substring(startIndex, i + 1)));
+                    }
+                    openCount--;
                 }
-                openCount--;
+                i++;
+            }
+            let group1 = (_a = queryParams[0]) !== null && _a !== void 0 ? _a : {};
+            let group2 = (_b = queryParams[1]) !== null && _b !== void 0 ? _b : {};
+            let group3 = (_c = queryParams[2]) !== null && _c !== void 0 ? _c : {};
+            if (mode === "update") {
+                return {
+                    filter: group1,
+                    update: group2,
+                    options: group3,
+                };
             }
-            i++;
-        }
-        let group1 = (_a = queryParams[0]) !== null && _a !== void 0 ? _a : {};
-        let group2 = (_b = queryParams[1]) !== null && _b !== void 0 ? _b : {};
-        let group3 = (_c = queryParams[2]) !== null && _c !== void 0 ? _c : {};
-        if (mode === "update") {
             return {
                 filter: group1,
-                update: group2,
-                options: group3,
+                options: group2,
             };
         }
-        return {
-            filter: group1,
-            options: group2,
-        };
-    }
-    create(query) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                yield this.connect();
-                const db = this.client.db(this.config.db);
-                const collection = db.collection(query.extra.collection);
-                let json = this.createObjectIds(query.json);
-                // For mongodb we add an extra actionType to specify
-                // which method we want to call on the collection
-                switch (query.extra.actionTypes) {
-                    case "insertOne": {
-                        return yield collection.insertOne(json);
-                    }
-                    case "insertMany": {
-                        return yield collection.insertMany(json);
-                    }
-                    default: {
-                        throw new Error(`actionType ${query.extra.actionTypes} does not exist on DB for create`);
+        create(query) {
+            return __awaiter(this, void 0, void 0, function* () {
+                try {
+                    yield this.connect();
+                    const db = this.client.db(this.config.db);
+                    const collection = db.collection(query.extra.collection);
+                    let json = this.createObjectIds(query.json);
+                    // For mongodb we add an extra actionType to specify
+                    // which method we want to call on the collection
+                    switch (query.extra.actionTypes) {
+                        case "insertOne": {
+                            return yield collection.insertOne(json);
+                        }
+                        case "insertMany": {
+                            return yield collection.insertMany(json);
+                        }
+                        default: {
+                            throw new Error(`actionType ${query.extra.actionTypes} does not exist on DB for create`);
+                        }
                     }
                 }
-            }
-            catch (err) {
-                console.error("Error writing to mongodb", err);
-                throw err;
-            }
-            finally {
-                yield this.client.close();
-            }
-        });
-    }
-    read(query) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                yield this.connect();
-                const db = this.client.db(this.config.db);
-                const collection = db.collection(query.extra.collection);
-                let json = this.createObjectIds(query.json);
-                switch (query.extra.actionTypes) {
-                    case "find": {
-                        return yield collection.find(json).toArray();
-                    }
-                    case "findOne": {
-                        return yield collection.findOne(json);
-                    }
-                    case "findOneAndUpdate": {
-                        if (typeof query.json === "string") {
-                            json = this.parseQueryParams(query.json, "update");
+                catch (err) {
+                    console.error("Error writing to mongodb", err);
+                    throw err;
+                }
+                finally {
+                    yield this.client.close();
+                }
+            });
+        }
+        read(query) {
+            return __awaiter(this, void 0, void 0, function* () {
+                try {
+                    yield this.connect();
+                    const db = this.client.db(this.config.db);
+                    const collection = db.collection(query.extra.collection);
+                    let json = this.createObjectIds(query.json);
+                    switch (query.extra.actionTypes) {
+                        case "find": {
+                            return yield collection.find(json).toArray();
+                        }
+                        case "findOne": {
+                            return yield collection.findOne(json);
+                        }
+                        case "findOneAndUpdate": {
+                            if (typeof query.json === "string") {
+                                json = this.parseQueryParams(query.json, "update");
+                            }
+                            let findAndUpdateJson = this.createObjectIds(json);
+                            return yield collection.findOneAndUpdate(findAndUpdateJson.filter, findAndUpdateJson.update, findAndUpdateJson.options);
+                        }
+                        case "count": {
+                            return yield collection.countDocuments(json);
+                        }
+                        case "distinct": {
+                            return yield collection.distinct(json);
+                        }
+                        default: {
+                            throw new Error(`actionType ${query.extra.actionTypes} does not exist on DB for read`);
                         }
-                        let findAndUpdateJson = this.createObjectIds(json);
-                        return yield collection.findOneAndUpdate(findAndUpdateJson.filter, findAndUpdateJson.update, findAndUpdateJson.options);
-                    }
-                    case "count": {
-                        return yield collection.countDocuments(json);
-                    }
-                    case "distinct": {
-                        return yield collection.distinct(json);
-                    }
-                    default: {
-                        throw new Error(`actionType ${query.extra.actionTypes} does not exist on DB for read`);
                     }
                 }
-            }
-            catch (err) {
-                console.error("Error querying mongodb", err);
-                throw err;
-            }
-            finally {
-                yield this.client.close();
-            }
-        });
-    }
-    update(query) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                yield this.connect();
-                const db = this.client.db(this.config.db);
-                const collection = db.collection(query.extra.collection);
-                let queryJson = query.json;
-                if (typeof queryJson === "string") {
-                    queryJson = this.parseQueryParams(queryJson, "update");
+                catch (err) {
+                    console.error("Error querying mongodb", err);
+                    throw err;
                 }
-                let json = this.createObjectIds(queryJson);
-                switch (query.extra.actionTypes) {
-                    case "updateOne": {
-                        return yield collection.updateOne(json.filter, json.update, json.options);
-                    }
-                    case "updateMany": {
-                        return yield collection.updateMany(json.filter, json.update, json.options);
+                finally {
+                    yield this.client.close();
+                }
+            });
+        }
+        update(query) {
+            return __awaiter(this, void 0, void 0, function* () {
+                try {
+                    yield this.connect();
+                    const db = this.client.db(this.config.db);
+                    const collection = db.collection(query.extra.collection);
+                    let queryJson = query.json;
+                    if (typeof queryJson === "string") {
+                        queryJson = this.parseQueryParams(queryJson, "update");
                     }
-                    default: {
-                        throw new Error(`actionType ${query.extra.actionTypes} does not exist on DB for update`);
+                    let json = this.createObjectIds(queryJson);
+                    switch (query.extra.actionTypes) {
+                        case "updateOne": {
+                            return yield collection.updateOne(json.filter, json.update, json.options);
+                        }
+                        case "updateMany": {
+                            return yield collection.updateMany(json.filter, json.update, json.options);
+                        }
+                        default: {
+                            throw new Error(`actionType ${query.extra.actionTypes} does not exist on DB for update`);
+                        }
                     }
                 }
-            }
-            catch (err) {
-                console.error("Error writing to mongodb", err);
-                throw err;
-            }
-            finally {
-                yield this.client.close();
-            }
-        });
-    }
-    delete(query) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                yield this.connect();
-                const db = this.client.db(this.config.db);
-                const collection = db.collection(query.extra.collection);
-                let queryJson = query.json;
-                if (typeof queryJson === "string") {
-                    queryJson = this.parseQueryParams(queryJson, "delete");
+                catch (err) {
+                    console.error("Error writing to mongodb", err);
+                    throw err;
                 }
-                let json = this.createObjectIds(queryJson);
-                if (!json.options) {
-                    json = {
-                        filter: json,
-                        options: {},
-                    };
+                finally {
+                    yield this.client.close();
                 }
-                switch (query.extra.actionTypes) {
-                    case "deleteOne": {
-                        return yield collection.deleteOne(json.filter, json.options);
+            });
+        }
+        delete(query) {
+            return __awaiter(this, void 0, void 0, function* () {
+                try {
+                    yield this.connect();
+                    const db = this.client.db(this.config.db);
+                    const collection = db.collection(query.extra.collection);
+                    let queryJson = query.json;
+                    if (typeof queryJson === "string") {
+                        queryJson = this.parseQueryParams(queryJson, "delete");
                     }
-                    case "deleteMany": {
-                        return yield collection.deleteMany(json.filter, json.options);
+                    let json = this.createObjectIds(queryJson);
+                    if (!json.options) {
+                        json = {
+                            filter: json,
+                            options: {},
+                        };
                     }
-                    default: {
-                        throw new Error(`actionType ${query.extra.actionTypes} does not exist on DB for delete`);
+                    switch (query.extra.actionTypes) {
+                        case "deleteOne": {
+                            return yield collection.deleteOne(json.filter, json.options);
+                        }
+                        case "deleteMany": {
+                            return yield collection.deleteMany(json.filter, json.options);
+                        }
+                        default: {
+                            throw new Error(`actionType ${query.extra.actionTypes} does not exist on DB for delete`);
+                        }
                     }
                 }
-            }
-            catch (err) {
-                console.error("Error writing to mongodb", err);
-                throw err;
-            }
-            finally {
-                yield this.client.close();
-            }
-        });
+                catch (err) {
+                    console.error("Error writing to mongodb", err);
+                    throw err;
+                }
+                finally {
+                    yield this.client.close();
+                }
+            });
+        }
     }
-}
-exports.default = {
-    schema: SCHEMA,
-    integration: MongoIntegration,
-};
+    module.exports = {
+        schema: SCHEMA,
+        integration: MongoIntegration,
+    };
+})(MongoDBModule || (MongoDBModule = {}));