@budibase/server 2.4.41 → 2.4.42-alpha.1

package/src/integration-test/postgres.spec.ts

@@ -1,3 +1,6 @@
+import fetch from "node-fetch"
+// @ts-ignore
+fetch.mockSearch()
 import {
   generateMakeRequest,
   MakeRequestResponse,
@@ -16,6 +19,7 @@ import _ from "lodash"
 import { generator } from "@budibase/backend-core/tests"
 import { utils } from "@budibase/backend-core"
 import { GenericContainer } from "testcontainers"
+import { generateRowIdField } from "../integrations/utils"
 
 const config = setup.getConfig()!
 
@@ -80,16 +84,10 @@ describe("row api - postgres", () => {
             name: "id",
             type: FieldType.AUTO,
             autocolumn: true,
-            constraints: {
-              presence: true,
-            },
           },
           title: {
             name: "title",
             type: FieldType.STRING,
-            constraints: {
-              presence: true,
-            },
           },
         },
         sourceId: postgresDatasource._id,
@@ -121,16 +119,10 @@ describe("row api - postgres", () => {
           name: "id",
           type: FieldType.AUTO,
           autocolumn: true,
-          constraints: {
-            presence: true,
-          },
         },
         name: {
           name: "name",
           type: FieldType.STRING,
-          constraints: {
-            presence: true,
-          },
         },
         description: {
           name: "description",
@@ -144,7 +136,6 @@ describe("row api - postgres", () => {
           type: FieldType.LINK,
           constraints: {
             type: "array",
-            presence: false,
           },
           fieldName: oneToManyRelationshipInfo.fieldName,
           name: "oneToManyRelation",
@@ -156,7 +147,6 @@ describe("row api - postgres", () => {
           type: FieldType.LINK,
           constraints: {
             type: "array",
-            presence: false,
           },
           fieldName: manyToOneRelationshipInfo.fieldName,
           name: "manyToOneRelation",
@@ -168,7 +158,6 @@ describe("row api - postgres", () => {
           type: FieldType.LINK,
           constraints: {
             type: "array",
-            presence: false,
           },
           fieldName: manyToManyRelationshipInfo.fieldName,
           name: "manyToManyRelation",
@@ -309,9 +298,6 @@ describe("row api - postgres", () => {
         id: {
           name: "id",
           type: FieldType.AUTO,
-          constraints: {
-            presence: true,
-          },
         },
       },
       sourceId: postgresDatasource._id,
@@ -921,47 +907,55 @@ describe("row api - postgres", () => {
             foreignRows,
             x => x.relationshipType
           )
-          expect(res.body).toEqual({
-            ...rowData,
-            [`fk_${oneToManyRelationshipInfo.table.name}_${oneToManyRelationshipInfo.fieldName}`]:
-              foreignRowsByType[RelationshipTypes.ONE_TO_MANY][0].row.id,
-            [oneToManyRelationshipInfo.fieldName]: [
-              {
-                ...foreignRowsByType[RelationshipTypes.ONE_TO_MANY][0].row,
-                _id: expect.any(String),
-                _rev: expect.any(String),
-              },
-            ],
-            [manyToOneRelationshipInfo.fieldName]: [
-              {
-                ...foreignRowsByType[RelationshipTypes.MANY_TO_ONE][0].row,
-                [`fk_${manyToOneRelationshipInfo.table.name}_${manyToOneRelationshipInfo.fieldName}`]:
-                  row.id,
-              },
-              {
-                ...foreignRowsByType[RelationshipTypes.MANY_TO_ONE][1].row,
-                [`fk_${manyToOneRelationshipInfo.table.name}_${manyToOneRelationshipInfo.fieldName}`]:
-                  row.id,
-              },
+          const m2mFieldName = manyToManyRelationshipInfo.fieldName,
+            o2mFieldName = oneToManyRelationshipInfo.fieldName,
+            m2oFieldName = manyToOneRelationshipInfo.fieldName
+          const m2mRow1 = res.body[m2mFieldName].find(
+            (row: Row) => row.id === 1
+          )
+          const m2mRow2 = res.body[m2mFieldName].find(
+            (row: Row) => row.id === 2
+          )
+          expect(m2mRow1).toEqual({
+            ...foreignRowsByType[RelationshipTypes.MANY_TO_MANY][0].row,
+            [m2mFieldName]: [
               {
-                ...foreignRowsByType[RelationshipTypes.MANY_TO_ONE][2].row,
-                [`fk_${manyToOneRelationshipInfo.table.name}_${manyToOneRelationshipInfo.fieldName}`]:
-                  row.id,
+                _id: row._id,
               },
             ],
-            [manyToManyRelationshipInfo.fieldName]: [
-              {
-                ...foreignRowsByType[RelationshipTypes.MANY_TO_MANY][0].row,
-              },
+          })
+          expect(m2mRow2).toEqual({
+            ...foreignRowsByType[RelationshipTypes.MANY_TO_MANY][1].row,
+            [m2mFieldName]: [
               {
-                ...foreignRowsByType[RelationshipTypes.MANY_TO_MANY][1].row,
+                _id: row._id,
               },
             ],
-            id: row.id,
-            tableId: row.tableId,
-            _id: expect.any(String),
-            _rev: expect.any(String),
           })
+          expect(res.body[m2oFieldName]).toEqual([
+            {
+              ...foreignRowsByType[RelationshipTypes.MANY_TO_ONE][0].row,
+              [`fk_${manyToOneRelationshipInfo.table.name}_${manyToOneRelationshipInfo.fieldName}`]:
+                row.id,
+            },
+            {
+              ...foreignRowsByType[RelationshipTypes.MANY_TO_ONE][1].row,
+              [`fk_${manyToOneRelationshipInfo.table.name}_${manyToOneRelationshipInfo.fieldName}`]:
+                row.id,
+            },
+            {
+              ...foreignRowsByType[RelationshipTypes.MANY_TO_ONE][2].row,
+              [`fk_${manyToOneRelationshipInfo.table.name}_${manyToOneRelationshipInfo.fieldName}`]:
+                row.id,
+            },
+          ])
+          expect(res.body[o2mFieldName]).toEqual([
+            {
+              ...foreignRowsByType[RelationshipTypes.ONE_TO_MANY][0].row,
+              _id: expect.any(String),
+              _rev: expect.any(String),
+            },
+          ])
         })
       })
     })

package/src/integrations/redis.ts

@@ -92,7 +92,7 @@ class RedisIntegration {
   }
 
   async disconnect() {
-    return this.client.disconnect()
+    return this.client.quit()
   }
 
   async redisContext(query: Function) {

package/src/integrations/tests/googlesheets.spec.ts

@@ -39,6 +39,10 @@ describe("Google Sheets Integration", () => {
     config.setGoogleAuth("test")
   })
 
+  afterAll(async () => {
+    await config.end()
+  })
+
   beforeEach(async () => {
     integration = new GoogleSheetsIntegration.integration({
       spreadsheetId: "randomId",
@@ -99,8 +103,8 @@ describe("Google Sheets Integration", () => {
       })
     })
 
-    test("removing an existing field will not remove the data from the spreadsheet", async () => {
-      await config.doInContext(structures.uuid(), async () => {
+    test("removing an existing field will remove the header from the google sheet", async () => {
+      const sheet = await config.doInContext(structures.uuid(), async () => {
         const tableColumns = ["name"]
         const table = createBasicTable(structures.uuid(), tableColumns)
 
@@ -109,18 +113,14 @@ describe("Google Sheets Integration", () => {
         })
         sheetsByTitle[table.name] = sheet
         await integration.updateTable(table)
-
-        expect(sheet.loadHeaderRow).toBeCalledTimes(1)
-        expect(sheet.setHeaderRow).toBeCalledTimes(1)
-        expect(sheet.setHeaderRow).toBeCalledWith([
-          "name",
-          "description",
-          "location",
-        ])
-
-        // No undefineds are sent
-        expect((sheet.setHeaderRow as any).mock.calls[0][0]).toHaveLength(3)
+        return sheet
       })
+      expect(sheet.loadHeaderRow).toBeCalledTimes(1)
+      expect(sheet.setHeaderRow).toBeCalledTimes(1)
+      expect(sheet.setHeaderRow).toBeCalledWith(["name"])
+
+      // No undefined are sent
+      expect((sheet.setHeaderRow as any).mock.calls[0][0]).toHaveLength(1)
     })
   })
 })

package/src/integrations/tests/redis.spec.ts

@@ -3,17 +3,17 @@ import { default as RedisIntegration } from "../redis"
 
 class TestConfiguration {
   integration: any
-  redis: any
 
   constructor(config: any = {}) {
     this.integration = new RedisIntegration.integration(config)
-    this.redis = new Redis({
+    // have to kill the basic integration before replacing it
+    this.integration.client.quit()
+    this.integration.client = new Redis({
       data: {
         test: "test",
         result: "1",
       },
     })
-    this.integration.client = this.redis
   }
 }
 
@@ -24,13 +24,17 @@ describe("Redis Integration", () => {
     config = new TestConfiguration()
   })
 
+  afterAll(() => {
+    config.integration.disconnect()
+  })
+
   it("calls the create method with the correct params", async () => {
     const body = {
       key: "key",
       value: "value",
     }
     await config.integration.create(body)
-    expect(await config.redis.get("key")).toEqual("value")
+    expect(await config.integration.client.get("key")).toEqual("value")
   })
 
   it("calls the read method with the correct params", async () => {
@@ -46,7 +50,7 @@ describe("Redis Integration", () => {
       key: "test",
     }
     await config.integration.delete(body)
-    expect(await config.redis.get(body.key)).toEqual(null)
+    expect(await config.integration.client.get(body.key)).toEqual(null)
   })
 
   it("calls the pipeline method with the correct params", async () => {

package/src/middleware/currentapp.ts

@@ -10,9 +10,9 @@ import { generateUserMetadataID, isDevAppID } from "../db/utils"
 import { getCachedSelf } from "../utilities/global"
 import env from "../environment"
 import { isWebhookEndpoint } from "./utils"
-import { BBContext } from "@budibase/types"
+import { UserCtx } from "@budibase/types"
 
-export default async (ctx: BBContext, next: any) => {
+export default async (ctx: UserCtx, next: any) => {
   // try to get the appID from the request
   let requestAppId = await utils.getAppIdFromCtx(ctx)
   // get app cookie if it exists

package/src/sdk/users/utils.ts

@@ -9,7 +9,10 @@ import { isEqual } from "lodash"
 
 export function combineMetadataAndUser(user: any, metadata: any) {
   // skip users with no access
-  if (user.roleId === rolesCore.BUILTIN_ROLE_IDS.PUBLIC) {
+  if (
+    user.roleId == null ||
+    user.roleId === rolesCore.BUILTIN_ROLE_IDS.PUBLIC
+  ) {
     return null
   }
   delete user._rev

package/src/tests/jestEnv.ts

@@ -9,3 +9,4 @@ process.env.LOG_LEVEL = process.env.LOG_LEVEL || "error"
 process.env.ENABLE_4XX_HTTP_LOGGING = "0"
 process.env.MOCK_REDIS = "1"
 process.env.PLATFORM_URL = "http://localhost:10000"
+process.env.REDIS_PASSWORD = "budibase"

package/src/tests/jestSetup.ts

@@ -1,6 +1,6 @@
 import "./logging"
 import env from "../environment"
-import { env as coreEnv } from "@budibase/backend-core"
+import { env as coreEnv, timers } from "@budibase/backend-core"
 import { testContainerUtils } from "@budibase/backend-core/tests"
 
 if (!process.env.DEBUG) {
@@ -17,3 +17,7 @@ if (!process.env.CI) {
 }
 
 testContainerUtils.setupEnv(env, coreEnv)
+
+afterAll(() => {
+  timers.cleanup()
+})

package/src/tests/utilities/TestConfiguration.ts

@@ -46,6 +46,7 @@ import {
   Row,
   SourceName,
   Table,
+  SearchFilters,
 } from "@budibase/types"
 
 type DefaultUserValues = {
@@ -164,6 +165,8 @@ class TestConfiguration {
     }
     if (this.server) {
       this.server.close()
+    } else {
+      require("../../app").default.close()
     }
     if (this.allApps) {
       cleanup(this.allApps.map(app => app.appId))
@@ -568,6 +571,16 @@ class TestConfiguration {
     return this._req(null, { tableId }, controllers.row.fetch)
   }
 
+  async searchRows(tableId: string, searchParams: SearchFilters = {}) {
+    if (!tableId && this.table) {
+      tableId = this.table._id
+    }
+    const body = {
+      query: searchParams,
+    }
+    return this._req(body, { tableId }, controllers.row.search)
+  }
+
   // ROLE
 
   async createRole(config?: any) {

package/src/tests/utilities/structures.ts

@@ -106,7 +106,7 @@ export function newAutomation({ steps, trigger }: any = {}) {
   return automation
 }
 
-export function basicAutomation() {
+export function basicAutomation(appId?: string) {
   return {
     name: "My Automation",
     screenId: "kasdkfldsafkl",
@@ -114,11 +114,23 @@ export function basicAutomation() {
     uiTree: {},
     definition: {
       trigger: {
+        stepId: AutomationTriggerStepId.APP,
+        name: "test",
+        tagline: "test",
+        icon: "test",
+        description: "test",
+        type: "trigger",
+        id: "test",
         inputs: {},
+        schema: {
+          inputs: {},
+          outputs: {},
+        },
       },
       steps: [],
     },
     type: "automation",
+    appId,
   }
 }
 

package/src/utilities/global.ts

@@ -8,7 +8,7 @@ import {
 } from "@budibase/backend-core"
 import env from "../environment"
 import { groups } from "@budibase/pro"
-import { BBContext, ContextUser, User } from "@budibase/types"
+import { UserCtx, ContextUser, User, UserGroup } from "@budibase/types"
 
 export function updateAppRole(
   user: ContextUser,
@@ -43,33 +43,40 @@ export function updateAppRole(
 
 async function checkGroupRoles(
   user: ContextUser,
-  { appId }: { appId?: string } = {}
+  opts: { appId?: string; groups?: UserGroup[] } = {}
 ) {
   if (user.roleId && user.roleId !== roles.BUILTIN_ROLE_IDS.PUBLIC) {
     return user
   }
-  if (appId) {
-    user.roleId = await groups.getGroupRoleId(user as User, appId)
+  if (opts.appId) {
+    user.roleId = await groups.getGroupRoleId(user as User, opts.appId, {
+      groups: opts.groups,
+    })
+  }
+  // final fallback, simply couldn't find a role - user must be public
+  if (!user.roleId) {
+    user.roleId = roles.BUILTIN_ROLE_IDS.PUBLIC
   }
   return user
 }
 
 async function processUser(
   user: ContextUser,
-  { appId }: { appId?: string } = {}
+  opts: { appId?: string; groups?: UserGroup[] } = {}
 ) {
   if (user) {
     delete user.password
   }
-  user = await updateAppRole(user, { appId })
+  const appId = opts.appId || context.getAppId()
+  user = updateAppRole(user, { appId })
   if (!user.roleId && user?.userGroups?.length) {
-    user = await checkGroupRoles(user, { appId })
+    user = await checkGroupRoles(user, { appId, groups: opts?.groups })
   }
 
   return user
 }
 
-export async function getCachedSelf(ctx: BBContext, appId: string) {
+export async function getCachedSelf(ctx: UserCtx, appId: string) {
   // this has to be tenant aware, can't depend on the context to find it out
   // running some middlewares before the tenancy causes context to break
   const user = await cache.user.getUser(ctx.user?._id!)
@@ -90,6 +97,7 @@ export async function getGlobalUser(userId: string) {
 export async function getGlobalUsers(users?: ContextUser[]) {
   const appId = context.getAppId()
   const db = tenancy.getGlobalDB()
+  const allGroups = await groups.fetch()
   let globalUsers
   if (users) {
     const globalIds = users.map(user =>
@@ -118,7 +126,11 @@ export async function getGlobalUsers(users?: ContextUser[]) {
     return globalUsers
   }
 
-  return globalUsers.map(user => updateAppRole(user))
+  // pass in the groups, meaning we don't actually need to retrieve them for
+  // each user individually
+  return Promise.all(
+    globalUsers.map(user => processUser(user, { groups: allGroups }))
+  )
 }
 
 export async function getGlobalUsersFromMetadata(users: ContextUser[]) {