@budibase/server 1.0.162 → 1.0.164

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@budibase/server",
   "email": "hi@budibase.com",
-  "version": "1.0.162",
+  "version": "1.0.164",
   "description": "Budibase Web Server",
   "main": "src/index.ts",
   "repository": {
@@ -69,10 +69,10 @@
   "license": "GPL-3.0",
   "dependencies": {
     "@apidevtools/swagger-parser": "^10.0.3",
-    "@budibase/backend-core": "^1.0.162",
-    "@budibase/client": "^1.0.162",
-    "@budibase/pro": "1.0.161",
-    "@budibase/string-templates": "^1.0.162",
+    "@budibase/backend-core": "^1.0.164",
+    "@budibase/client": "^1.0.164",
+    "@budibase/pro": "1.0.163",
+    "@budibase/string-templates": "^1.0.164",
     "@bull-board/api": "^3.7.0",
     "@bull-board/koa": "^3.7.0",
     "@elastic/elasticsearch": "7.10.0",
@@ -152,6 +152,7 @@
     "@types/koa": "^2.13.3",
     "@types/koa-router": "^7.4.2",
     "@types/lodash": "4.14.180",
+    "@types/mongodb": "3.6.3",
     "@types/node": "^15.12.4",
     "@types/oracledb": "^5.2.1",
     "@types/redis": "^4.0.11",
@@ -181,5 +182,5 @@
   "optionalDependencies": {
     "oracledb": "^5.3.0"
   },
-  "gitHead": "55bda2267ec49a0d075234a53218ee66ae7efe10"
+  "gitHead": "9e99a13c690c9a51cfd76fe67bd07eec17c00996"
 }

package/src/integrations/mongodb.ts

@@ -4,10 +4,18 @@ import {
   QueryTypes,
 } from "../definitions/datasource"
 import { IntegrationBase } from "./base/IntegrationBase"
+import {
+  MongoClient,
+  ObjectID,
+  FilterQuery,
+  UpdateQuery,
+  FindOneAndUpdateOption,
+  UpdateOneOptions,
+  UpdateManyOptions,
+  CommonOptions,
+} from "mongodb"
 
 module MongoDBModule {
-  const { MongoClient } = require("mongodb")
-
   interface MongoDBConfig {
     connectionString: string
     db: string
@@ -76,20 +84,76 @@ module MongoDBModule {
       return this.client.connect()
     }
 
+    createObjectIds(json: any): object {
+      const self = this
+      function interpolateObjectIds(json: any) {
+        for (let field of Object.keys(json)) {
+          if (json[field] instanceof Object) {
+            json[field] = self.createObjectIds(json[field])
+          }
+          if (field === "_id" && typeof json[field] === "string") {
+            const id = json["_id"].match(
+              /(?<=objectid\(['"]).*(?=['"]\))/gi
+            )?.[0]
+            if (id) {
+              json["_id"] = 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: string, mode: string) {
+      let queryParams = params.split(/(?<=(},)).*{/g)
+      let group1 = queryParams[0]
+      let group2 = queryParams[2]
+      let group3 = queryParams[4]
+      if (group1) {
+        group1 = JSON.parse(group1.replace(/,+$/, ""))
+      }
+      if (group2) {
+        group2 = JSON.parse("{" + group2.replace(/,+$/, ""))
+      }
+      if (group3) {
+        group3 = JSON.parse("{" + group3.replace(/,+$/, ""))
+      }
+      if (mode === "update") {
+        return {
+          filter: group1,
+          update: group2,
+          options: group3 ?? {},
+        }
+      }
+      return {
+        filter: group1,
+        options: group2 ?? {},
+      }
+    }
+
     async create(query: { json: object; extra: { [key: string]: string } }) {
       try {
         await 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 await collection.insertOne(query.json)
+            return await collection.insertOne(json)
           }
           case "insertMany": {
-            return await collection.insertOne(query.json).toArray()
+            return await collection.insertMany(json)
           }
           default: {
             throw new Error(
@@ -110,22 +174,32 @@ module MongoDBModule {
         await 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 await collection.find(query.json).toArray()
+            return await collection.find(json).toArray()
           }
           case "findOne": {
-            return await collection.findOne(query.json)
+            return await collection.findOne(json)
           }
           case "findOneAndUpdate": {
-            return await collection.findOneAndUpdate(query.json)
+            let findAndUpdateJson = json as {
+              filter: FilterQuery<any>
+              update: UpdateQuery<any>
+              options: FindOneAndUpdateOption<any>
+            }
+            return await collection.findOneAndUpdate(
+              findAndUpdateJson.filter,
+              findAndUpdateJson.update,
+              findAndUpdateJson.options
+            )
           }
           case "count": {
-            return await collection.countDocuments(query.json)
+            return await collection.countDocuments(json)
           }
           case "distinct": {
-            return await collection.distinct(query.json)
+            return await collection.distinct(json)
           }
           default: {
             throw new Error(
@@ -146,13 +220,30 @@ module MongoDBModule {
         await 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) as {
+          filter: FilterQuery<any>
+          update: UpdateQuery<any>
+          options: object
+        }
 
         switch (query.extra.actionTypes) {
           case "updateOne": {
-            return await collection.updateOne(query.json)
+            return await collection.updateOne(
+              json.filter,
+              json.update,
+              json.options as UpdateOneOptions
+            )
           }
           case "updateMany": {
-            return await collection.updateMany(query.json).toArray()
+            return await collection.updateMany(
+              json.filter,
+              json.update,
+              json.options as UpdateManyOptions
+            )
           }
           default: {
             throw new Error(
@@ -173,13 +264,21 @@ module MongoDBModule {
         await 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) as {
+          filter: FilterQuery<any>
+          options: CommonOptions
+        }
 
         switch (query.extra.actionTypes) {
           case "deleteOne": {
-            return await collection.deleteOne(query.json)
+            return await collection.deleteOne(json.filter, json.options)
           }
           case "deleteMany": {
-            return await collection.deleteMany(query.json).toArray()
+            return await collection.deleteMany(json.filter, json.options)
           }
           default: {
             throw new Error(

package/src/integrations/tests/mongo.spec.js

@@ -4,19 +4,19 @@ jest.mock("mongodb")
 
 class TestConfiguration {
   constructor(config = {}) {
-    this.integration = new MongoDBIntegration.integration(config) 
+    this.integration = new MongoDBIntegration.integration(config)
   }
 }
 
 function disableConsole() {
-  jest.spyOn(console, 'error');
-  console.error.mockImplementation(() => {});
+  jest.spyOn(console, "error")
+  console.error.mockImplementation(() => {})
 
-  return console.error.mockRestore;
+  return console.error.mockRestore
 }
 
 describe("MongoDB Integration", () => {
-  let config 
+  let config
   let indexName = "Users"
 
   beforeEach(() => {
@@ -25,12 +25,12 @@ describe("MongoDB Integration", () => {
 
   it("calls the create method with the correct params", async () => {
     const body = {
-      name: "Hello"
+      name: "Hello",
     }
     await config.integration.create({
       index: indexName,
       json: body,
-      extra: { collection: 'testCollection', actionTypes: 'insertOne'}
+      extra: { collection: "testCollection", actionTypes: "insertOne" },
     })
     expect(config.integration.client.insertOne).toHaveBeenCalledWith(body)
   })
@@ -38,9 +38,9 @@ describe("MongoDB Integration", () => {
   it("calls the read method with the correct params", async () => {
     const query = {
       json: {
-        address: "test"
+        address: "test",
       },
-      extra: { collection: 'testCollection', actionTypes: 'find'}
+      extra: { collection: "testCollection", actionTypes: "find" },
     }
     const response = await config.integration.read(query)
     expect(config.integration.client.find).toHaveBeenCalledWith(query.json)
@@ -50,30 +50,47 @@ describe("MongoDB Integration", () => {
   it("calls the delete method with the correct params", async () => {
     const query = {
       json: {
-        id: "test"
+        filter: {
+          id: "test",
+        },
+        options: {
+          opt: "option"
+        }
       },
-      extra: { collection: 'testCollection', actionTypes: 'deleteOne'}
+      extra: { collection: "testCollection", actionTypes: "deleteOne" },
     }
     await config.integration.delete(query)
-    expect(config.integration.client.deleteOne).toHaveBeenCalledWith(query.json)
+    expect(config.integration.client.deleteOne).toHaveBeenCalledWith(query.json.filter, query.json.options)
   })
 
   it("calls the update method with the correct params", async () => {
     const query = {
       json: {
-        id: "test"
+        filter: {
+          id: "test",
+        },
+        update: {
+          name: "TestName",
+        },
+        options: {
+          upsert: false,
+        },
       },
-      extra: { collection: 'testCollection', actionTypes: 'updateOne'}
+      extra: { collection: "testCollection", actionTypes: "updateOne" },
     }
     await config.integration.update(query)
-    expect(config.integration.client.updateOne).toHaveBeenCalledWith(query.json)
+    expect(config.integration.client.updateOne).toHaveBeenCalledWith(
+      query.json.filter,
+      query.json.update,
+      query.json.options
+    )
   })
 
   it("throws an error when an invalid query.extra.actionType is passed for each method", async () => {
     const restore = disableConsole()
 
     const query = {
-      extra: { collection: 'testCollection', actionTypes: 'deleteOne'}
+      extra: { collection: "testCollection", actionTypes: "deleteOne" },
     }
 
     let error = null
@@ -85,4 +102,4 @@ describe("MongoDB Integration", () => {
     expect(error).toBeDefined()
     restore()
   })
-})
+})