@budibase/server 1.1.27 → 1.1.29-alpha.1

package/dist/utilities/global.js

@@ -16,6 +16,7 @@ const { user: userCache } = require("@budibase/backend-core/cache");
 const { getGlobalDB, isUserInAppTenant, } = require("@budibase/backend-core/tenancy");
 const env = require("../environment");
 const { getAppId } = require("@budibase/backend-core/context");
+const { groups } = require("@budibase/pro");
 exports.updateAppRole = (user, { appId } = {}) => {
     appId = appId || getAppId();
     if (!user || !user.roles) {
@@ -40,11 +41,27 @@ exports.updateAppRole = (user, { appId } = {}) => {
     delete user.roles;
     return user;
 };
+function checkGroupRoles(user, { appId } = {}) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!user.roleId) {
+            let roleId = yield groups.getGroupRoleId(user, appId);
+            user.roleId = roleId;
+        }
+        return user;
+    });
+}
 function processUser(user, { appId } = {}) {
-    if (user) {
-        delete user.password;
-    }
-    return exports.updateAppRole(user, { appId });
+    var _a;
+    return __awaiter(this, void 0, void 0, function* () {
+        if (user) {
+            delete user.password;
+        }
+        user = yield exports.updateAppRole(user, { appId });
+        if ((_a = user === null || user === void 0 ? void 0 : user.userGroups) === null || _a === void 0 ? void 0 : _a.length) {
+            user = yield checkGroupRoles(user, { appId });
+        }
+        return user;
+    });
 }
 exports.getCachedSelf = (ctx, appId) => __awaiter(void 0, void 0, void 0, function* () {
     // this has to be tenant aware, can't depend on the context to find it out

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@budibase/server",
   "email": "hi@budibase.com",
-  "version": "1.1.27",
+  "version": "1.1.29-alpha.1",
   "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": "^1.1.27",
-    "@budibase/client": "^1.1.27",
-    "@budibase/pro": "1.1.26",
-    "@budibase/string-templates": "^1.1.27",
-    "@budibase/types": "^1.1.27",
+    "@budibase/backend-core": "^1.1.29-alpha.1",
+    "@budibase/client": "^1.1.29-alpha.1",
+    "@budibase/pro": "1.1.29-alpha.0",
+    "@budibase/string-templates": "^1.1.29-alpha.1",
+    "@budibase/types": "^1.1.29-alpha.1",
     "@bull-board/api": "3.7.0",
     "@bull-board/koa": "3.9.4",
     "@elastic/elasticsearch": "7.10.0",
@@ -118,7 +118,7 @@
     "koa-send": "5.0.0",
     "koa-session": "5.12.0",
     "koa-static": "5.0.0",
-    "koa2-ratelimit": "1.1.0",
+    "koa2-ratelimit": "1.1.1",
     "lodash": "4.17.21",
     "memorystream": "0.3.1",
     "mongodb": "3.6.3",
@@ -137,7 +137,7 @@
     "redis": "4",
     "server-destroy": "1.0.1",
     "snowflake-promise": "^4.5.0",
-    "svelte": "3.44.1",
+    "svelte": "3.49.0",
     "swagger-parser": "10.0.3",
     "to-json-schema": "0.2.5",
     "uuid": "3.3.2",
@@ -195,5 +195,5 @@
   "optionalDependencies": {
     "oracledb": "5.3.0"
   },
-  "gitHead": "ce7b4989f2a9e575370f4ccfd7fa9d8db27dfc13"
+  "gitHead": "f00000b82e47fffa6341c813cfce59f76384b3a5"
 }

package/src/api/controllers/query/index.ts

@@ -246,7 +246,7 @@ async function execute(
 }
 
 export async function executeV1(ctx: any) {
-  return execute(ctx, { rowsOnly: true })
+  return execute(ctx, { rowsOnly: true, isAutomation: false })
 }
 
 export async function executeV2(

package/src/api/controllers/query/validation.js

@@ -1,4 +1,4 @@
-const joiValidator = require("../../../middleware/joi-validator")
+const { joiValidator } = require("@budibase/backend-core/auth")
 const Joi = require("joi")
 
 const OPTIONAL_STRING = Joi.string().optional().allow(null).allow("")

package/src/api/controllers/row/internalSearch.js

@@ -19,6 +19,7 @@ class QueryBuilder {
       empty: {},
       notEmpty: {},
       oneOf: {},
+      contains: {},
       ...base,
     }
     this.limit = 50
@@ -119,6 +120,11 @@ class QueryBuilder {
     return this
   }
 
+  addContains(key, value) {
+    this.query.contains[key] = value
+    return this
+  }
+
   /**
    * Preprocesses a value before going into a lucene search.
    * Transforms strings to lowercase and wraps strings and bools in quotes.
@@ -164,6 +170,31 @@ class QueryBuilder {
       return `${key}:${builder.preprocess(value, allPreProcessingOpts)}`
     }
 
+    const contains = (key, value) => {
+      if (!value && value !== 0) {
+        return null
+      }
+      return `${key}:${builder.preprocess(value, { escape: true })}`
+    }
+
+    const oneOf = (key, value) => {
+      if (!Array.isArray(value)) {
+        if (typeof value === "string") {
+          value = value.split(",")
+        } else {
+          return ""
+        }
+      }
+      let orStatement = `${builder.preprocess(value[0], allPreProcessingOpts)}`
+      for (let i = 1; i < value.length; i++) {
+        orStatement += ` OR ${builder.preprocess(
+          value[i],
+          allPreProcessingOpts
+        )}`
+      }
+      return `${key}:(${orStatement})`
+    }
+
     function build(structure, queryFn) {
       for (let [key, value] of Object.entries(structure)) {
         key = builder.preprocess(key.replace(/ /g, "_"), {
@@ -239,26 +270,10 @@ class QueryBuilder {
       build(this.query.notEmpty, key => `${key}:["" TO *]`)
     }
     if (this.query.oneOf) {
-      build(this.query.oneOf, (key, value) => {
-        if (!Array.isArray(value)) {
-          if (typeof value === "string") {
-            value = value.split(",")
-          } else {
-            return ""
-          }
-        }
-        let orStatement = `${builder.preprocess(
-          value[0],
-          allPreProcessingOpts
-        )}`
-        for (let i = 1; i < value.length; i++) {
-          orStatement += ` OR ${builder.preprocess(
-            value[i],
-            allPreProcessingOpts
-          )}`
-        }
-        return `${key}:(${orStatement})`
-      })
+      build(this.query.oneOf, oneOf)
+    }
+    if (this.query.contains) {
+      build(this.query.contains, contains)
     }
     // make sure table ID is always added as an AND
     if (tableId) {

package/src/api/routes/tests/user.spec.js

@@ -23,6 +23,7 @@ describe("/users", () => {
   })
 
   describe("fetch", () => {
+
     it("returns a list of users from an instance db", async () => {
       await config.createUser("uuidx")
       await config.createUser("uuidy")
@@ -37,6 +38,7 @@ describe("/users", () => {
       expect(res.body.find(u => u._id === `ro_ta_users_us_uuidy`)).toBeDefined()
     })
 
+
     it("should apply authorization to endpoint", async () => {
       await config.createUser()
       await checkPermissionsEndpoint({

package/src/api/routes/utils/validators.js

@@ -1,4 +1,4 @@
-const joiValidator = require("../../../middleware/joi-validator")
+const { joiValidator } = require("@budibase/backend-core/auth")
 const { DataSourceOperation } = require("../../../constants")
 const { WebhookType } = require("../../../constants")
 const {

package/src/automations/steps/executeQuery.js

@@ -74,6 +74,7 @@ exports.run = async function ({ inputs, appId, emitter }) {
   try {
     await queryController.executeV2(ctx, { isAutomation: true })
     const { data, ...rest } = ctx.body
+
     return {
       response: data,
       info: rest,

package/src/automations/steps/queryRows.js

@@ -96,12 +96,14 @@ exports.run = async function ({ inputs, appId }) {
       tableId,
     },
     body: {
-      sortOrder,
       sortType,
+      limit,
       sort: sortColumn,
       query: filters || {},
-      limit,
+      // default to ascending, like data tab
+      sortOrder: sortOrder || SortOrders.ASCENDING,
     },
+    version: "1",
   })
   try {
     await rowController.search(ctx)

package/src/automations/steps/utils.js

@@ -17,7 +17,8 @@ exports.getFetchResponse = async fetched => {
 // need to make sure all ctx structures have the
 // throw added to them, so that controllers don't
 // throw a ctx.throw undefined when error occurs
-exports.buildCtx = (appId, emitter, { body, params } = {}) => {
+// opts can contain, body, params and version
+exports.buildCtx = (appId, emitter, opts = {}) => {
   const ctx = {
     appId,
     user: { appId },
@@ -26,11 +27,14 @@ exports.buildCtx = (appId, emitter, { body, params } = {}) => {
       throw error
     },
   }
-  if (body) {
-    ctx.request = { body }
+  if (opts.body) {
+    ctx.request = { body: opts.body }
   }
-  if (params) {
-    ctx.params = params
+  if (opts.params) {
+    ctx.params = opts.params
+  }
+  if (opts.version) {
+    ctx.version = opts.version
   }
   return ctx
 }

package/src/definitions/datasource.ts

@@ -131,6 +131,9 @@ export interface SearchFilters {
   oneOf?: {
     [key: string]: any[]
   }
+  contains?: {
+    [key: string]: any
+  }
 }
 
 export interface SortJson {

package/src/integrations/base/sql.ts

@@ -142,6 +142,21 @@ class InternalBuilder {
         }
       }
     }
+
+    const like = (key: string, value: any) => {
+      const fnc = allOr ? "orWhere" : "where"
+      // postgres supports ilike, nothing else does
+      if (this.client === SqlClients.POSTGRES) {
+        query = query[fnc](key, "ilike", `%${value}%`)
+      } else {
+        const rawFnc = `${fnc}Raw`
+        // @ts-ignore
+        query = query[rawFnc](`LOWER(${likeKey(this.client, key)}) LIKE ?`, [
+          `%${value}%`,
+        ])
+      }
+    }
+
     if (!filters) {
       return query
     }
@@ -168,19 +183,7 @@ class InternalBuilder {
       })
     }
     if (filters.fuzzy) {
-      iterate(filters.fuzzy, (key, value) => {
-        const fnc = allOr ? "orWhere" : "where"
-        // postgres supports ilike, nothing else does
-        if (this.client === SqlClients.POSTGRES) {
-          query = query[fnc](key, "ilike", `%${value}%`)
-        } else {
-          const rawFnc = `${fnc}Raw`
-          // @ts-ignore
-          query = query[rawFnc](`LOWER(${likeKey(this.client, key)}) LIKE ?`, [
-            `%${value}%`,
-          ])
-        }
-      })
+      iterate(filters.fuzzy, like)
     }
     if (filters.range) {
       iterate(filters.range, (key, value) => {
@@ -223,6 +226,34 @@ class InternalBuilder {
         query = query[fnc](key)
       })
     }
+    if (filters.contains) {
+      const fnc = allOr ? "orWhere" : "where"
+      const rawFnc = `${fnc}Raw`
+      if (this.client === SqlClients.POSTGRES) {
+        iterate(filters.contains, (key: string, value: any) => {
+          const fieldNames = key.split(/\./g)
+          const tableName = fieldNames[0]
+          const columnName = fieldNames[1]
+          if (typeof value === "string") {
+            value = `"${value}"`
+          }
+          // @ts-ignore
+          query = query[rawFnc](
+            `"${tableName}"."${columnName}"::jsonb @> '[${value}]'`
+          )
+        })
+      } else if (this.client === SqlClients.MY_SQL) {
+        iterate(filters.contains, (key: string, value: any) => {
+          if (typeof value === "string") {
+            value = `"${value}"`
+          }
+          // @ts-ignore
+          query = query[rawFnc](`JSON_CONTAINS(${key}, '${value}')`)
+        })
+      } else {
+        iterate(filters.contains, like)
+      }
+    }
     return query
   }
 

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

@@ -1,4 +1,5 @@
 const Sql = require("../base/sql")
+const { SqlClients } = require("../utils")
 
 const TABLE_NAME = "test"
 
@@ -46,7 +47,7 @@ function generateDeleteJson(table = TABLE_NAME, filters = {}) {
 
 describe("SQL query builder", () => {
   const limit = 500
-  const client = "pg"
+  const client = SqlClients.POSTGRES
   let sql
 
   beforeEach(() => {
@@ -173,15 +174,15 @@ describe("SQL query builder", () => {
   })
 
   it("should work with MS-SQL", () => {
-    const query = new Sql("mssql", 10)._query(generateReadJson())
+    const query = new Sql(SqlClients.MS_SQL, 10)._query(generateReadJson())
     expect(query).toEqual({
       bindings: [10],
       sql: `select * from (select top (@p0) * from [${TABLE_NAME}]) as [${TABLE_NAME}]`
     })
   })
 
-  it("should work with mySQL", () => {
-    const query = new Sql("mysql", 10)._query(generateReadJson())
+  it("should work with MySQL", () => {
+    const query = new Sql(SqlClients.MY_SQL, 10)._query(generateReadJson())
     expect(query).toEqual({
       bindings: [10],
       sql: `select * from (select * from \`${TABLE_NAME}\` limit ?) as \`${TABLE_NAME}\``
@@ -238,4 +239,49 @@ describe("SQL query builder", () => {
       sql: `select * from (select * from "${TABLE_NAME}" where "${TABLE_NAME}"."property" > $1 limit $2) as "${TABLE_NAME}"`
     })
   })
+
+  it("should use like expression for MS-SQL when filter is contains", () => {
+    const query = new Sql(SqlClients.MS_SQL, 10)._query(generateReadJson({
+      filters: {
+        contains: {
+          age: 20,
+          name: "John"
+        }
+      }
+    }))
+    expect(query).toEqual({
+      bindings: [10, "%20%", "%John%"],
+      sql: `select * from (select top (@p0) * from [${TABLE_NAME}] where LOWER(${TABLE_NAME}.age) LIKE @p1 and LOWER(${TABLE_NAME}.name) LIKE @p2) as [${TABLE_NAME}]`
+    })
+  })
+
+  it("should use JSON_CONTAINS expression for MySQL when filter is contains", () => {
+    const query = new Sql(SqlClients.MY_SQL, 10)._query(generateReadJson({
+      filters: {
+        contains: {
+          age: 20,
+          name: "John"
+        }
+      }
+    }))
+    expect(query).toEqual({
+      bindings: [10],
+      sql: `select * from (select * from \`${TABLE_NAME}\` where JSON_CONTAINS(${TABLE_NAME}.age, '20') and JSON_CONTAINS(${TABLE_NAME}.name, '"John"') limit ?) as \`${TABLE_NAME}\``
+    })
+  })
+
+  it("should use jsonb operator expression for PostgreSQL when filter is contains", () => {
+    const query = new Sql(SqlClients.POSTGRES, 10)._query(generateReadJson({
+      filters: {
+        contains: {
+          age: 20,
+          name: "John"
+        }
+      }
+    }))
+    expect(query).toEqual({
+      bindings: [10],
+      sql: `select * from (select * from \"${TABLE_NAME}\" where \"${TABLE_NAME}\".\"age\"::jsonb @> '[20]' and \"${TABLE_NAME}\".\"name\"::jsonb @> '["John"]' limit $1) as \"${TABLE_NAME}\"`
+    })
+  })
 })

package/src/middleware/tests/currentapp.spec.js

@@ -1,5 +1,6 @@
 mockAuthWithNoCookie()
 mockWorker()
+mockUserGroups()
 
 jest.mock("@budibase/backend-core/db", () => {
   const coreDb = jest.requireActual("@budibase/backend-core/db")
@@ -29,6 +30,16 @@ function mockReset() {
   mockWorker()
 }
 
+function mockUserGroups() {
+  jest.mock("@budibase/pro", () => ({
+    groups: {
+      getGroupRoleId: () => {
+        return "BASIC"
+      },
+    },
+  }))
+}
+
 function mockAuthWithNoCookie() {
   jest.resetModules()
   mockWorker()

package/src/utilities/global.js

@@ -12,9 +12,11 @@ const {
 } = require("@budibase/backend-core/tenancy")
 const env = require("../environment")
 const { getAppId } = require("@budibase/backend-core/context")
+const { groups } = require("@budibase/pro")
 
 exports.updateAppRole = (user, { appId } = {}) => {
   appId = appId || getAppId()
+
   if (!user || !user.roles) {
     return user
   }
@@ -33,15 +35,30 @@ exports.updateAppRole = (user, { appId } = {}) => {
   } else if (!user.roleId) {
     user.roleId = BUILTIN_ROLE_IDS.PUBLIC
   }
+
   delete user.roles
   return user
 }
 
-function processUser(user, { appId } = {}) {
+async function checkGroupRoles(user, { appId } = {}) {
+  if (!user.roleId) {
+    let roleId = await groups.getGroupRoleId(user, appId)
+    user.roleId = roleId
+  }
+
+  return user
+}
+
+async function processUser(user, { appId } = {}) {
   if (user) {
     delete user.password
   }
-  return exports.updateAppRole(user, { appId })
+  user = await exports.updateAppRole(user, { appId })
+  if (user?.userGroups?.length) {
+    user = await checkGroupRoles(user, { appId })
+  }
+
+  return user
 }
 
 exports.getCachedSelf = async (ctx, appId) => {
@@ -89,6 +106,7 @@ exports.getGlobalUsers = async (users = null) => {
   if (!appId) {
     return globalUsers
   }
+
   return globalUsers.map(user => exports.updateAppRole(user))
 }