@budibase/server 2.6.19-alpha.2 → 2.6.19-alpha.20

package/dist/integrations/mongodb.js

@@ -1,630 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __asyncValues = (this && this.__asyncValues) || function (o) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var m = o[Symbol.asyncIterator], i;
-    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
-    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
-    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const types_1 = require("@budibase/types");
-const mongodb_1 = require("mongodb");
-const environment_1 = __importDefault(require("../environment"));
-const getSchema = () => {
-    let 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.",
-        features: [types_1.DatasourceFeature.CONNECTION_CHECKING],
-        datasource: {
-            connectionString: {
-                type: types_1.DatasourceFieldType.STRING,
-                required: true,
-                default: "mongodb://localhost:27017",
-                display: "Connection string",
-            },
-            db: {
-                type: types_1.DatasourceFieldType.STRING,
-                required: true,
-                display: "DB",
-            },
-        },
-        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,
-            },
-            aggregate: {
-                type: types_1.QueryType.JSON,
-                readable: true,
-                steps: [
-                    {
-                        key: "$addFields",
-                        template: "{\n\t\n}",
-                    },
-                    {
-                        key: "$bucket",
-                        template: `{
-    "groupBy": "",
-    "boundaries": [],
-    "default": "",
-    "output": {}
-  }`,
-                    },
-                    {
-                        key: "$bucketAuto",
-                        template: `{
-    "groupBy": "",
-    "buckets": 1,
-    "output": {},
-    "granularity": "R5"
-  }`,
-                    },
-                    {
-                        key: "$changeStream",
-                        template: `{
-    "allChangesForCluster": true,
-    "fullDocument": "",
-    "fullDocumentBeforeChange": "",
-    "resumeAfter": 1,
-    "showExpandedEvents": true,
-    "startAfter": {},
-    "startAtOperationTime": ""
-  }`,
-                    },
-                    {
-                        key: "$collStats",
-                        template: `{
-    "latencyStats": { "histograms": true } },
-    "storageStats": { "scale": 1 } },
-    "count": {},
-    "queryExecStats": {}
-  }`,
-                    },
-                    {
-                        key: "$count",
-                        template: ``,
-                    },
-                    {
-                        key: "$densify",
-                        template: `{
-    "field": "",
-    "partitionByFields": [],
-    "range": {
-      "step": 1,
-      "unit": 1,
-      "bounds": "full"
-    }
-  }`,
-                    },
-                    {
-                        key: "$documents",
-                        template: `[]`,
-                    },
-                    {
-                        key: "$facet",
-                        template: `{\n\t\n}`,
-                    },
-                    {
-                        key: "$fill",
-                        template: `{
-    "partitionBy": "",
-    "partitionByFields": [],
-    "sortBy": {},
-    "output": {}
-  }`,
-                    },
-                    {
-                        key: "$geoNear",
-                        template: `{
-    "near": { 
-      "type": "Point", 
-      "coordinates": [ 
-        -73.98142, 40.71782
-      ] 
-    },
-    "key": "location",
-    "distanceField": "dist.calculated",
-    "query": { "category": "Parks" }
-  }`,
-                    },
-                    {
-                        key: "$graphLookup",
-                        template: `{
-    "from": "",
-    "startWith": "",
-    "connectFromField": "",
-    "connectToField": "",
-    "as": "",
-    "maxDepth": 1,
-    "depthField": "",
-    "restrictSearchWithMatch": {}
-  }`,
-                    },
-                    {
-                        key: "$group",
-                        template: `{
-    "_id": ""
-  }`,
-                    },
-                    {
-                        key: "$indexStats",
-                        template: "{\n\t\n}",
-                    },
-                    {
-                        key: "$limit",
-                        template: `1`,
-                    },
-                    {
-                        key: "$listLocalSessions",
-                        template: `{\n\t\n}`,
-                    },
-                    {
-                        key: "$listSessions",
-                        template: `{\n\t\n}`,
-                    },
-                    {
-                        key: "$lookup",
-                        template: `{
-    "from": "",
-    "localField": "",
-    "foreignField": "",
-    "as": ""
-  }`,
-                    },
-                    {
-                        key: "$match",
-                        template: "{\n\t\n}",
-                    },
-                    {
-                        key: "$merge",
-                        template: `{
-    "into": {},
-    "on": "_id",
-    "whenMatched": "replace",
-    "whenNotMatched": "insert"
-  }`,
-                    },
-                    {
-                        key: "$out",
-                        template: `{
-    "db": "",
-    "coll": ""
-  }`,
-                    },
-                    {
-                        key: "$planCacheStats",
-                        template: "{\n\t\n}",
-                    },
-                    {
-                        key: "$project",
-                        template: "{\n\t\n}",
-                    },
-                    {
-                        key: "$redact",
-                        template: "",
-                    },
-                    {
-                        key: "$replaceRoot",
-                        template: `{ "newRoot": "" }`,
-                    },
-                    {
-                        key: "$replaceWith",
-                        template: ``,
-                    },
-                    {
-                        key: "$sample",
-                        template: `{ "size": 3 }`,
-                    },
-                    {
-                        key: "$set",
-                        template: "{\n\t\n}",
-                    },
-                    {
-                        key: "$setWindowFields",
-                        template: `{
-    "partitionBy": "",
-    "sortBy": {},
-    "output": {}
-  }`,
-                    },
-                    {
-                        key: "$skip",
-                        template: `1`,
-                    },
-                    {
-                        key: "$sort",
-                        template: "{\n\t\n}",
-                    },
-                    {
-                        key: "$sortByCount",
-                        template: "",
-                    },
-                    {
-                        key: "$unionWith",
-                        template: `{
-    "coll": "",
-    "pipeline": []
-  }`,
-                    },
-                    {
-                        key: "$unset",
-                        template: "",
-                    },
-                    {
-                        key: "$unwind",
-                        template: `{
-    "path": "",
-    "includeArrayIndex": "",
-    "preserveNullAndEmptyArrays": true
-  }`,
-                    },
-                ],
-            },
-        },
-        extra: {
-            collection: {
-                displayName: "Collection",
-                type: types_1.DatasourceFieldType.STRING,
-                required: true,
-            },
-            actionType: {
-                displayName: "Query Type",
-                type: types_1.DatasourceFieldType.LIST,
-                required: true,
-                data: {
-                    read: ["find", "findOne", "findOneAndUpdate", "count", "distinct"],
-                    create: ["insertOne", "insertMany"],
-                    update: ["updateOne", "updateMany"],
-                    delete: ["deleteOne", "deleteMany"],
-                    aggregate: ["json", "pipeline"],
-                },
-            },
-        },
-    };
-    if (environment_1.default.SELF_HOSTED) {
-        schema.datasource = Object.assign(Object.assign({}, schema.datasource), { 
-            //@ts-ignore
-            tls: {
-                type: types_1.DatasourceFieldType.FIELD_GROUP,
-                display: "Configure SSL",
-                fields: {
-                    tlsCertificateFile: {
-                        type: types_1.DatasourceFieldType.STRING,
-                        required: false,
-                        display: "Certificate file path",
-                    },
-                    tlsCertificateKeyFile: {
-                        type: types_1.DatasourceFieldType.STRING,
-                        required: false,
-                        display: "Certificate Key file path",
-                    },
-                    tlsCAFile: {
-                        type: types_1.DatasourceFieldType.STRING,
-                        required: false,
-                        display: "CA file path",
-                    },
-                },
-            } });
-    }
-    return schema;
-};
-const SCHEMA = getSchema();
-class MongoIntegration {
-    constructor(config) {
-        this.config = config;
-        const options = {
-            tlsCertificateFile: config.tlsCertificateFile || undefined,
-            tlsCertificateKeyFile: config.tlsCertificateKeyFile || undefined,
-            tlsCAFile: config.tlsCAFile || undefined,
-        };
-        this.client = new mongodb_1.MongoClient(config.connectionString, options);
-    }
-    testConnection() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const response = {
-                connected: false,
-            };
-            try {
-                yield this.connect();
-                response.connected = true;
-            }
-            catch (e) {
-                response.error = e.message;
-            }
-            return response;
-        });
-    }
-    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;
-        }
-        if (Array.isArray(json)) {
-            for (let i = 0; i < json.length; i++) {
-                json[i] = interpolateObjectIds(json[i]);
-            }
-            return 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;
-                }
-            }
-            else if (c === "}" && !inQuotes) {
-                if (openCount === 1) {
-                    queryParams.push(JSON.parse(params.substring(startIndex, i + 1)));
-                }
-                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,
-            };
-        }
-        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.actionType) {
-                    case "insertOne": {
-                        return yield collection.insertOne(json);
-                    }
-                    case "insertMany": {
-                        return yield collection.insertMany(json);
-                    }
-                    default: {
-                        throw new Error(`actionType ${query.extra.actionType} 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.actionType) {
-                    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.actionType} 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");
-                }
-                let json = this.createObjectIds(queryJson);
-                switch (query.extra.actionType) {
-                    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.actionType} 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");
-                }
-                let json = this.createObjectIds(queryJson);
-                if (!json.options) {
-                    json = {
-                        filter: json,
-                        options: {},
-                    };
-                }
-                switch (query.extra.actionType) {
-                    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.actionType} does not exist on DB for delete`);
-                    }
-                }
-            }
-            catch (err) {
-                console.error("Error writing to mongodb", err);
-                throw err;
-            }
-            finally {
-                yield this.client.close();
-            }
-        });
-    }
-    aggregate(query) {
-        var e_1, _a, e_2, _b;
-        var _c;
-        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 response = [];
-                if (((_c = query.extra) === null || _c === void 0 ? void 0 : _c.actionType) === "pipeline") {
-                    try {
-                        for (var _d = __asyncValues(collection.aggregate(query.steps.map(({ key, value }) => {
-                            let temp = {};
-                            temp[key] = JSON.parse(value.value);
-                            return this.createObjectIds(temp);
-                        }))), _e; _e = yield _d.next(), !_e.done;) {
-                            const doc = _e.value;
-                            response.push(doc);
-                        }
-                    }
-                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
-                    finally {
-                        try {
-                            if (_e && !_e.done && (_a = _d.return)) yield _a.call(_d);
-                        }
-                        finally { if (e_1) throw e_1.error; }
-                    }
-                }
-                else {
-                    const stages = query.json;
-                    try {
-                        for (var _f = __asyncValues(collection.aggregate(stages ? this.createObjectIds(stages) : [])), _g; _g = yield _f.next(), !_g.done;) {
-                            const doc = _g.value;
-                            response.push(doc);
-                        }
-                    }
-                    catch (e_2_1) { e_2 = { error: e_2_1 }; }
-                    finally {
-                        try {
-                            if (_g && !_g.done && (_b = _f.return)) yield _b.call(_f);
-                        }
-                        finally { if (e_2) throw e_2.error; }
-                    }
-                }
-                return response;
-            }
-            catch (err) {
-                console.error("Error writing to mongodb", err);
-                throw err;
-            }
-            finally {
-                yield this.client.close();
-            }
-        });
-    }
-}
-exports.default = {
-    schema: SCHEMA,
-    integration: MongoIntegration,
-};