@budibase/server 1.2.36 → 1.2.39-alpha.0

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

@@ -102,4 +102,222 @@ describe("MongoDB Integration", () => {
     expect(error).toBeDefined()
     restore()
   })
+
+  it("creates ObjectIds if the _id fields contains a match on ObjectId", async () => {
+    const query = {
+      json: {
+        filter: {
+          _id: "ObjectId('ACBD12345678ABCD12345678')",
+          name: "ObjectId('name')"
+        },
+        update: {
+          _id: "ObjectId('FFFF12345678ABCD12345678')",
+          name: "ObjectId('updatedName')",
+        },
+        options: {
+          upsert: false,
+        },
+      },
+      extra: { collection: "testCollection", actionTypes: "updateOne" },
+    }
+    await config.integration.update(query)
+    expect(config.integration.client.updateOne).toHaveBeenCalled()
+    
+    const args = config.integration.client.updateOne.mock.calls[0]
+    expect(args[0]).toEqual({
+      _id: mongo.ObjectID.createFromHexString("ACBD12345678ABCD12345678"),
+      name: "ObjectId('name')",
+    })
+    expect(args[1]).toEqual({
+      _id: mongo.ObjectID.createFromHexString("FFFF12345678ABCD12345678"),
+      name: "ObjectId('updatedName')",
+    })
+    expect(args[2]).toEqual({
+      upsert: false
+    })
+  })
+
+  it("creates ObjectIds if the $ operator fields contains a match on ObjectId", async () => {
+    const query = {
+      json: {
+        filter: {
+          _id: {
+            $eq: "ObjectId('ACBD12345678ABCD12345678')",
+          }
+        },
+        update: {
+          $set: {
+            _id: "ObjectId('FFFF12345678ABCD12345678')",
+          },
+        },
+        options: {
+          upsert: true,
+        },
+      },
+      extra: { collection: "testCollection", actionTypes: "updateOne" },
+    }
+    await config.integration.update(query)
+    expect(config.integration.client.updateOne).toHaveBeenCalled()
+    
+    const args = config.integration.client.updateOne.mock.calls[0]
+    expect(args[0]).toEqual({
+      _id: {
+        $eq: mongo.ObjectID.createFromHexString("ACBD12345678ABCD12345678"),
+      }
+    })
+    expect(args[1]).toEqual({
+      $set: {
+        _id: mongo.ObjectID.createFromHexString("FFFF12345678ABCD12345678"),
+      }
+    })
+    expect(args[2]).toEqual({
+      upsert: true
+    })
+  })
+
+  it("supports findOneAndUpdate", async () => {
+    const query = {
+      json: {
+        filter: {
+          _id: {
+            $eq: "ObjectId('ACBD12345678ABCD12345678')",
+          }
+        },
+        update: {
+          $set: {
+            name: "UPDATED",
+            age: 99
+          },
+        },
+        options: {
+          upsert: false,
+        },
+      },
+      extra: { collection: "testCollection", actionTypes: "findOneAndUpdate" },
+    }
+    await config.integration.read(query)
+    expect(config.integration.client.findOneAndUpdate).toHaveBeenCalled()
+    
+    const args = config.integration.client.findOneAndUpdate.mock.calls[0]
+    expect(args[0]).toEqual({
+      _id: {
+        $eq: mongo.ObjectID.createFromHexString("ACBD12345678ABCD12345678"),
+      }
+    })
+    expect(args[1]).toEqual({
+      $set: {
+        name: "UPDATED",
+        age: 99
+      }
+    })
+    expect(args[2]).toEqual({
+      upsert: false
+    })
+  })
+
+  it("can parse nested objects with arrays", async () => {
+    const query = {
+      json: `{
+          "_id": {
+            "$eq": "ObjectId('ACBD12345678ABCD12345678')"
+          }
+        },
+        {
+          "$set": {
+            "value": {
+              "data": [
+                { "cid": 1 },
+                { "cid": 2 },
+                { "nested": {
+                  "name": "test"
+                }}
+              ]
+            }
+          }
+        },
+        {
+          "upsert": true
+        }`,
+      extra: { collection: "testCollection", actionTypes: "updateOne" },
+    }
+    await config.integration.update(query)
+    expect(config.integration.client.updateOne).toHaveBeenCalled()
+    
+    const args = config.integration.client.updateOne.mock.calls[0]
+    expect(args[0]).toEqual({
+      _id: {
+        $eq: mongo.ObjectID.createFromHexString("ACBD12345678ABCD12345678"),
+      }
+    })
+    expect(args[1]).toEqual({
+      $set: {
+        value: {
+          data: [
+            { cid: 1 },
+            { cid: 2 },
+            { nested: {
+              name: "test"
+            }}
+          ]
+        },
+      },
+    })
+    expect(args[2]).toEqual({
+      upsert: true
+    })
+  })
+
+  it("ignores braces within strings when parsing nested objects", async () => {
+    const query = {
+      json: `{
+          "_id": {
+            "$eq": "ObjectId('ACBD12345678ABCD12345678')"
+          }
+        },
+        {
+          "$set": {
+            "value": {
+              "data": [
+                { "cid": 1 },
+                { "cid": 2 },
+                { "nested": {
+                  "name": "te}st"
+                }}
+              ]
+            }
+          }
+        },
+        {
+          "upsert": true,
+          "extra": "ad\\"{\\"d"
+        }`,
+      extra: { collection: "testCollection", actionTypes: "updateOne" },
+    }
+    await config.integration.update(query)
+    expect(config.integration.client.updateOne).toHaveBeenCalled()
+    
+    const args = config.integration.client.updateOne.mock.calls[0]
+    expect(args[0]).toEqual({
+      _id: {
+        $eq: mongo.ObjectID.createFromHexString("ACBD12345678ABCD12345678"),
+      }
+    })
+    expect(args[1]).toEqual({
+      $set: {
+        value: {
+          data: [
+            { cid: 1 },
+            { cid: 2 },
+            { nested: {
+              name: "te}st"
+            }}
+          ]
+        },
+      },
+    })
+    expect(args[2]).toEqual({
+      upsert: true,
+      extra: "ad\"{\"d"
+    })
+  })
 })

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

@@ -1,5 +1,5 @@
-const Sql = require("../base/sql")
-const { SqlClients } = require("../utils")
+const Sql = require("../base/sql").default
+const { SqlClient } = require("../utils")
 
 const TABLE_NAME = "test"
 
@@ -47,7 +47,7 @@ function generateDeleteJson(table = TABLE_NAME, filters = {}) {
 
 describe("SQL query builder", () => {
   const limit = 500
-  const client = SqlClients.POSTGRES
+  const client = SqlClient.POSTGRES
   let sql
 
   beforeEach(() => {
@@ -174,7 +174,7 @@ describe("SQL query builder", () => {
   })
 
   it("should work with MS-SQL", () => {
-    const query = new Sql(SqlClients.MS_SQL, 10)._query(generateReadJson())
+    const query = new Sql(SqlClient.MS_SQL, 10)._query(generateReadJson())
     expect(query).toEqual({
       bindings: [10],
       sql: `select * from (select top (@p0) * from [${TABLE_NAME}]) as [${TABLE_NAME}]`
@@ -182,7 +182,7 @@ describe("SQL query builder", () => {
   })
 
   it("should work with MySQL", () => {
-    const query = new Sql(SqlClients.MY_SQL, 10)._query(generateReadJson())
+    const query = new Sql(SqlClient.MY_SQL, 10)._query(generateReadJson())
     expect(query).toEqual({
       bindings: [10],
       sql: `select * from (select * from \`${TABLE_NAME}\` limit ?) as \`${TABLE_NAME}\``
@@ -241,7 +241,7 @@ describe("SQL query builder", () => {
   })
 
   it("should use like expression for MS-SQL when filter is contains", () => {
-    const query = new Sql(SqlClients.MS_SQL, 10)._query(generateReadJson({
+    const query = new Sql(SqlClient.MS_SQL, 10)._query(generateReadJson({
       filters: {
         contains: {
           age: 20,
@@ -256,7 +256,7 @@ describe("SQL query builder", () => {
   })
 
   it("should use JSON_CONTAINS expression for MySQL when filter is contains", () => {
-    const query = new Sql(SqlClients.MY_SQL, 10)._query(generateReadJson({
+    const query = new Sql(SqlClient.MY_SQL, 10)._query(generateReadJson({
       filters: {
         contains: {
           age: 20,
@@ -271,7 +271,7 @@ describe("SQL query builder", () => {
   })
 
   it("should use jsonb operator expression for PostgreSQL when filter is contains", () => {
-    const query = new Sql(SqlClients.POSTGRES, 10)._query(generateReadJson({
+    const query = new Sql(SqlClient.POSTGRES, 10)._query(generateReadJson({
       filters: {
         contains: {
           age: 20,

package/src/integrations/utils.ts

@@ -1,6 +1,5 @@
-import { SourceNames, SqlQuery } from "../definitions/datasource"
-import { Datasource, Table } from "../definitions/common"
-import { DocumentTypes, SEPARATOR } from "../db/utils"
+import { SourceName, SqlQuery, Datasource, Table } from "@budibase/types"
+import { DocumentType, SEPARATOR } from "../db/utils"
 import { FieldTypes, BuildSchemaErrors, InvalidColumns } from "../constants"
 
 const DOUBLE_SEPARATOR = `${SEPARATOR}${SEPARATOR}`
@@ -68,7 +67,7 @@ const SQL_TYPE_MAP = {
   ...SQL_MISC_TYPE_MAP,
 }
 
-export enum SqlClients {
+export enum SqlClient {
   MS_SQL = "mssql",
   POSTGRES = "pg",
   MY_SQL = "mysql2",
@@ -76,7 +75,7 @@ export enum SqlClients {
 }
 
 export function isExternalTable(tableId: string) {
-  return tableId.includes(DocumentTypes.DATASOURCE)
+  return tableId.includes(DocumentType.DATASOURCE)
 }
 
 export function buildExternalTableId(datasourceId: string, tableName: string) {
@@ -169,10 +168,10 @@ export function isSQL(datasource: Datasource): boolean {
     return false
   }
   const SQL = [
-    SourceNames.POSTGRES,
-    SourceNames.SQL_SERVER,
-    SourceNames.MYSQL,
-    SourceNames.ORACLE,
+    SourceName.POSTGRES,
+    SourceName.SQL_SERVER,
+    SourceName.MYSQL,
+    SourceName.ORACLE,
   ]
   return SQL.indexOf(datasource.source) !== -1
 }

package/src/middleware/builder.js

@@ -6,7 +6,7 @@ const {
   setDebounce,
 } = require("../utilities/redis")
 const { doWithDB } = require("@budibase/backend-core/db")
-const { DocumentTypes, getGlobalIDFromUserMetadataID } = require("../db/utils")
+const { DocumentType, getGlobalIDFromUserMetadataID } = require("../db/utils")
 const { PermissionTypes } = require("@budibase/backend-core/permissions")
 const { app: appCache } = require("@budibase/backend-core/cache")
 
@@ -49,7 +49,7 @@ async function updateAppUpdatedAt(ctx) {
     return
   }
   await doWithDB(appId, async db => {
-    const metadata = await db.get(DocumentTypes.APP_METADATA)
+    const metadata = await db.get(DocumentType.APP_METADATA)
     metadata.updatedAt = new Date().toISOString()
 
     metadata.updatedBy = getGlobalIDFromUserMetadataID(ctx.user.userId)

package/src/migrations/functions/appUrls.ts

@@ -1,4 +1,4 @@
-const { DocumentTypes } = require("@budibase/backend-core/db")
+const { DocumentType } = require("@budibase/backend-core/db")
 import { getAppUrl } from "../../api/controllers/application"
 
 /**
@@ -11,7 +11,7 @@ import { getAppUrl } from "../../api/controllers/application"
 export const run = async (appDb: any) => {
   let metadata
   try {
-    metadata = await appDb.get(DocumentTypes.APP_METADATA)
+    metadata = await appDb.get(DocumentType.APP_METADATA)
   } catch (e) {
     // sometimes the metadata document doesn't exist
     // exit early instead of failing the migration

package/src/migrations/functions/backfill/app/queries.ts

@@ -1,6 +1,6 @@
 import { events } from "@budibase/backend-core"
 import { getQueryParams } from "../../../../db/utils"
-import { Query, Datasource } from "@budibase/types"
+import { Query, Datasource, SourceName } from "@budibase/types"
 
 const getQueries = async (appDb: any): Promise<Query[]> => {
   const response = await appDb.allDocs(
@@ -31,8 +31,9 @@ export const backfill = async (appDb: any, timestamp: string | number) => {
       // and the query has not
       if (e.status === 404) {
         datasource = {
+          type: "unknown",
           _id: query.datasourceId,
-          source: "unknown",
+          source: SourceName.UNKNOWN,
         }
       } else {
         throw e

package/src/migrations/functions/backfill/app.ts

@@ -62,7 +62,7 @@ export const run = async (appDb: any) => {
     await events.backfillCache.start(EVENTS)
 
     let timestamp: string | number = DEFAULT_TIMESTAMP
-    const app: App = await appDb.get(dbUtils.DocumentTypes.APP_METADATA)
+    const app: App = await appDb.get(dbUtils.DocumentType.APP_METADATA)
     if (app.createdAt) {
       timestamp = app.createdAt as string
     }

package/src/migrations/functions/backfill/global/users.ts

@@ -4,7 +4,7 @@ import { DEFAULT_TIMESTAMP } from ".."
 
 // manually define user doc params - normally server doesn't read users from the db
 const getUserParams = (props: any) => {
-  return dbUtils.getDocParams(dbUtils.DocumentTypes.USER, null, props)
+  return dbUtils.getDocParams(dbUtils.DocumentType.USER, null, props)
 }
 
 export const getUsers = async (globalDb: any): Promise<User[]> => {

package/src/migrations/functions/tests/appUrls.spec.js

@@ -1,4 +1,4 @@
-const { DocumentTypes, doWithDB } = require("@budibase/backend-core/db")
+const {  DocumentType, doWithDB } = require("@budibase/backend-core/db")
 const TestConfig = require("../../../tests/utilities/TestConfiguration")
 
 const migration = require("../appUrls")
@@ -15,11 +15,11 @@ describe("run", () => {
   it("runs successfully", async () => {
     const app = await config.createApp("testApp")
     const metadata = await doWithDB(app.appId, async db => {
-      const metadataDoc = await db.get(DocumentTypes.APP_METADATA)
+      const metadataDoc = await db.get( DocumentType.APP_METADATA)
       delete metadataDoc.url
       await db.put(metadataDoc)
       await migration.run(db)
-      return await db.get(DocumentTypes.APP_METADATA)
+      return await db.get( DocumentType.APP_METADATA)
     })
     expect(metadata.url).toEqual("/testapp")
   })

package/src/migrations/tests/index.spec.ts

@@ -2,7 +2,7 @@ import {
   events,
   migrations,
   tenancy,
-  DocumentTypes,
+  DocumentType,
   context,
   db,
 } from "@budibase/backend-core"
@@ -17,7 +17,7 @@ const timestamp = mocks.date.MOCK_DATE.toISOString()
 const clearMigrations = async () => {
   const dbs = [context.getDevAppDB(), context.getProdAppDB()]
   for (const db of dbs) {
-    const doc = await db.get(DocumentTypes.MIGRATIONS)
+    const doc = await db.get(DocumentType.MIGRATIONS)
     const newDoc = { _id: doc._id, _rev: doc._rev }
     await db.put(newDoc)
   }

package/src/tests/utilities/TestConfiguration.js

@@ -25,7 +25,7 @@ const newid = require("../../db/newid")
 const context = require("@budibase/backend-core/context")
 const { generateDevInfoID, SEPARATOR } = require("@budibase/backend-core/db")
 const { encrypt } = require("@budibase/backend-core/encryption")
-const { DocumentTypes } = require("../../db/utils")
+const { DocumentType } = require("../../db/utils")
 
 const GLOBAL_USER_ID = "us_uuid1"
 const EMAIL = "babs@babs.com"
@@ -344,7 +344,7 @@ class TestConfiguration {
 
     return context.doInAppContext(prodAppId, async () => {
       const db = context.getProdAppDB()
-      return await db.get(DocumentTypes.APP_METADATA)
+      return await db.get(DocumentType.APP_METADATA)
     })
   }
 

package/src/threads/automation.ts

@@ -11,7 +11,7 @@ import { storeLog } from "../automations/logging"
 import { Automation, AutomationStep, AutomationStatus } from "@budibase/types"
 import {
   LoopStep,
-  LoopStepTypes,
+  LoopStepType,
   LoopInput,
   AutomationEvent,
   TriggerOutput,
@@ -35,12 +35,12 @@ function typecastForLooping(loopStep: LoopStep, input: LoopInput) {
   }
   try {
     switch (loopStep.inputs.option) {
-      case LoopStepTypes.ARRAY:
+      case LoopStepType.ARRAY:
         if (typeof input.binding === "string") {
           return JSON.parse(input.binding)
         }
         break
-      case LoopStepTypes.STRING:
+      case LoopStepType.STRING:
         if (Array.isArray(input.binding)) {
           return input.binding.join(",")
         }

package/src/utilities/routing/index.js

@@ -1,11 +1,11 @@
 const { createRoutingView } = require("../../db/views/staticViews")
-const { ViewNames, getQueryIndex, UNICODE_MAX } = require("../../db/utils")
+const { ViewName, getQueryIndex, UNICODE_MAX } = require("../../db/utils")
 const { getAppDB } = require("@budibase/backend-core/context")
 
 exports.getRoutingInfo = async () => {
   const db = getAppDB()
   try {
-    const allRouting = await db.query(getQueryIndex(ViewNames.ROUTING), {
+    const allRouting = await db.query(getQueryIndex(ViewName.ROUTING), {
       startKey: "",
       endKey: UNICODE_MAX,
     })

package/src/utilities/security.js

@@ -8,7 +8,7 @@ const {
   lowerBuiltinRoleID,
   getBuiltinRoles,
 } = require("@budibase/backend-core/roles")
-const { DocumentTypes } = require("../db/utils")
+const { DocumentType } = require("../db/utils")
 
 const CURRENTLY_SUPPORTED_LEVELS = [
   PermissionLevels.WRITE,
@@ -17,19 +17,19 @@ const CURRENTLY_SUPPORTED_LEVELS = [
 ]
 
 exports.getPermissionType = resourceId => {
-  const docType = Object.values(DocumentTypes).filter(docType =>
+  const docType = Object.values(DocumentType).filter(docType =>
     resourceId.startsWith(docType)
   )[0]
   switch (docType) {
-    case DocumentTypes.TABLE:
-    case DocumentTypes.ROW:
+    case DocumentType.TABLE:
+    case DocumentType.ROW:
       return PermissionTypes.TABLE
-    case DocumentTypes.AUTOMATION:
+    case DocumentType.AUTOMATION:
       return PermissionTypes.AUTOMATION
-    case DocumentTypes.WEBHOOK:
+    case DocumentType.WEBHOOK:
       return PermissionTypes.WEBHOOK
-    case DocumentTypes.QUERY:
-    case DocumentTypes.DATASOURCE:
+    case DocumentType.QUERY:
+    case DocumentType.DATASOURCE:
       return PermissionTypes.QUERY
     default:
       // views don't have an ID, will end up here