@budibase/server 2.0.30-alpha.3 → 2.0.30-alpha.4

package/dist/constants/index.js

@@ -28,6 +28,7 @@ exports.NoEmptyFilterStrings = [
 ];
 exports.FieldTypes = {
     STRING: "string",
+    BARCODEQR: "barcodeqr",
     LONGFORM: "longform",
     OPTIONS: "options",
     NUMBER: "number",
@@ -47,6 +48,7 @@ exports.CanSwitchTypes = [
         exports.FieldTypes.STRING,
         exports.FieldTypes.OPTIONS,
         exports.FieldTypes.LONGFORM,
+        exports.FieldTypes.BARCODEQR,
     ],
     [exports.FieldTypes.BOOLEAN, exports.FieldTypes.NUMBER],
 ];

package/dist/integrations/base/sqlTable.js

@@ -31,6 +31,7 @@ function generateSchema(schema, table, tables, oldTable = null, renamed) {
             case FieldTypes.STRING:
             case FieldTypes.OPTIONS:
             case FieldTypes.LONGFORM:
+            case FieldTypes.BARCODEQR:
                 schema.text(key);
                 break;
             case FieldTypes.NUMBER:

package/dist/integrations/mongodb.js

@@ -8,6 +8,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         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); }
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const types_1 = require("@budibase/types");
 const mongodb_1 = require("mongodb");
@@ -40,6 +47,232 @@ const SCHEMA = {
         delete: {
             type: types_1.QueryType.JSON,
         },
+        aggregate: {
+            type: types_1.QueryType.JSON,
+            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: {
@@ -47,8 +280,8 @@ const SCHEMA = {
             type: types_1.DatasourceFieldType.STRING,
             required: true,
         },
-        actionTypes: {
-            displayName: "Action Types",
+        actionType: {
+            displayName: "Query Type",
             type: types_1.DatasourceFieldType.LIST,
             required: true,
             data: {
@@ -56,6 +289,7 @@ const SCHEMA = {
                 create: ["insertOne", "insertMany"],
                 update: ["updateOne", "updateMany"],
                 delete: ["deleteOne", "deleteMany"],
+                aggregate: ["json", "pipeline"],
             },
         },
     },
@@ -82,7 +316,7 @@ class MongoIntegration {
                     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);
+                        json[field] = mongodb_1.ObjectId.createFromHexString(id);
                     }
                 }
             }
@@ -145,7 +379,7 @@ class MongoIntegration {
                 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) {
+                switch (query.extra.actionType) {
                     case "insertOne": {
                         return yield collection.insertOne(json);
                     }
@@ -153,7 +387,7 @@ class MongoIntegration {
                         return yield collection.insertMany(json);
                     }
                     default: {
-                        throw new Error(`actionType ${query.extra.actionTypes} does not exist on DB for create`);
+                        throw new Error(`actionType ${query.extra.actionType} does not exist on DB for create`);
                     }
                 }
             }
@@ -173,7 +407,7 @@ class MongoIntegration {
                 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) {
+                switch (query.extra.actionType) {
                     case "find": {
                         return yield collection.find(json).toArray();
                     }
@@ -194,7 +428,7 @@ class MongoIntegration {
                         return yield collection.distinct(json);
                     }
                     default: {
-                        throw new Error(`actionType ${query.extra.actionTypes} does not exist on DB for read`);
+                        throw new Error(`actionType ${query.extra.actionType} does not exist on DB for read`);
                     }
                 }
             }
@@ -218,7 +452,7 @@ class MongoIntegration {
                     queryJson = this.parseQueryParams(queryJson, "update");
                 }
                 let json = this.createObjectIds(queryJson);
-                switch (query.extra.actionTypes) {
+                switch (query.extra.actionType) {
                     case "updateOne": {
                         return yield collection.updateOne(json.filter, json.update, json.options);
                     }
@@ -226,7 +460,7 @@ class MongoIntegration {
                         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`);
+                        throw new Error(`actionType ${query.extra.actionType} does not exist on DB for update`);
                     }
                 }
             }
@@ -256,7 +490,7 @@ class MongoIntegration {
                         options: {},
                     };
                 }
-                switch (query.extra.actionTypes) {
+                switch (query.extra.actionType) {
                     case "deleteOne": {
                         return yield collection.deleteOne(json.filter, json.options);
                     }
@@ -264,9 +498,64 @@ class MongoIntegration {
                         return yield collection.deleteMany(json.filter, json.options);
                     }
                     default: {
-                        throw new Error(`actionType ${query.extra.actionTypes} does not exist on DB for delete`);
+                        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);

package/dist/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@budibase/server",
     "email": "hi@budibase.com",
-    "version": "2.0.30-alpha.2",
+    "version": "2.0.30-alpha.3",
     "description": "Budibase Web Server",
     "main": "src/index.ts",
     "repository": {
@@ -77,11 +77,11 @@
     "license": "GPL-3.0",
     "dependencies": {
         "@apidevtools/swagger-parser": "10.0.3",
-        "@budibase/backend-core": "2.0.30-alpha.2",
-        "@budibase/client": "2.0.30-alpha.2",
-        "@budibase/pro": "2.0.30-alpha.2",
-        "@budibase/string-templates": "2.0.30-alpha.2",
-        "@budibase/types": "2.0.30-alpha.2",
+        "@budibase/backend-core": "2.0.30-alpha.3",
+        "@budibase/client": "2.0.30-alpha.3",
+        "@budibase/pro": "2.0.30-alpha.3",
+        "@budibase/string-templates": "2.0.30-alpha.3",
+        "@budibase/types": "2.0.30-alpha.3",
         "@bull-board/api": "3.7.0",
         "@bull-board/koa": "3.9.4",
         "@elastic/elasticsearch": "7.10.0",
@@ -123,7 +123,7 @@
         "koa2-ratelimit": "1.1.1",
         "lodash": "4.17.21",
         "memorystream": "0.3.1",
-        "mongodb": "3.6.3",
+        "mongodb": "4.9",
         "mssql": "6.2.3",
         "mysql2": "2.3.3",
         "node-fetch": "2.6.7",
@@ -166,7 +166,6 @@
         "@types/koa": "2.13.4",
         "@types/koa__router": "8.0.0",
         "@types/lodash": "4.14.180",
-        "@types/mongodb": "3.6.3",
         "@types/node": "14.18.20",
         "@types/node-fetch": "2.6.1",
         "@types/oracledb": "5.2.2",