@budibase/server 2.4.42-alpha.4 → 2.4.42

package/src/automations/tests/automation.spec.js

@@ -0,0 +1,84 @@
+jest.mock("../../threads/automation")
+jest.mock("../../utilities/redis", () => ({
+  init: jest.fn(),
+  checkTestFlag: () => {
+    return false
+  },
+}))
+
+jest.spyOn(global.console, "error")
+
+require("../../environment")
+const automation = require("../index")
+const thread = require("../../threads/automation")
+const triggers = require("../triggers")
+const { basicAutomation } = require("../../tests/utilities/structures")
+const { wait } = require("../../utilities")
+const { makePartial } = require("../../tests/utilities")
+const { cleanInputValues } = require("../automationUtils")
+const setup = require("./utilities")
+
+describe("Run through some parts of the automations system", () => {
+  let config = setup.getConfig()
+
+  beforeAll(async () => {
+    await automation.init()
+    await config.init()
+  })
+
+  afterAll(setup.afterAll)
+
+  it("should be able to init in builder", async () => {
+      await triggers.externalTrigger(basicAutomation(), { a: 1, appId: config.appId })
+      await wait(100)
+      expect(thread.execute).toHaveBeenCalled()
+  })
+
+  it("should check coercion", async () => {
+    const table = await config.createTable()
+    const automation = basicAutomation()
+    automation.definition.trigger.inputs.tableId = table._id
+    automation.definition.trigger.stepId = "APP"
+    automation.definition.trigger.inputs.fields = { a: "number" }
+    await triggers.externalTrigger(automation, {
+      appId: config.getAppId(),
+      fields: {
+        a: "1"
+      }
+    })
+    await wait(100)
+    expect(thread.execute).toHaveBeenCalledWith(makePartial({
+      data: {
+        event: {
+          fields: {
+            a: 1
+          }
+        }
+      }
+    }), expect.any(Function))
+  })
+
+  it("should be able to clean inputs with the utilities", () => {
+    // can't clean without a schema
+    let output = cleanInputValues({a: "1"})
+    expect(output.a).toBe("1")
+    output = cleanInputValues({a: "1", b: "true", c: "false", d: 1, e: "help"}, {
+      properties: {
+        a: {
+          type: "number",
+        },
+        b: {
+          type: "boolean",
+        },
+        c: {
+          type: "boolean",
+        }
+      }
+    })
+    expect(output.a).toBe(1)
+    expect(output.b).toBe(true)
+    expect(output.c).toBe(false)
+    expect(output.d).toBe(1)
+    expect(output.e).toBe("help")
+  })
+})

package/src/definitions/openapi.ts

@@ -22,10 +22,6 @@ export interface paths {
     /** Based on application properties (currently only name) search for applications. */
     post: operations["appSearch"];
   };
-  "/metrics": {
-    /** Output metrics in OpenMetrics format compatible with Prometheus */
-    get: operations["metricsGet"];
-  };
   "/queries/{queryId}": {
     /** Queries which have been created within a Budibase app can be executed using this, */
     post: operations["queryExecute"];
@@ -848,17 +844,6 @@ export interface operations {
       };
     };
   };
-  /** Output metrics in OpenMetrics format compatible with Prometheus */
-  metricsGet: {
-    responses: {
-      /** Returns tenant metrics. */
-      200: {
-        content: {
-          "text/plain": string;
-        };
-      };
-    };
-  };
   /** Queries which have been created within a Budibase app can be executed using this, */
   queryExecute: {
     parameters: {

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

@@ -1,6 +1,3 @@
-import fetch from "node-fetch"
-// @ts-ignore
-fetch.mockSearch()
 import {
   generateMakeRequest,
   MakeRequestResponse,
@@ -19,7 +16,6 @@ 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()!
 
@@ -84,10 +80,16 @@ 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,
@@ -119,10 +121,16 @@ 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",
@@ -136,6 +144,7 @@ describe("row api - postgres", () => {
           type: FieldType.LINK,
           constraints: {
             type: "array",
+            presence: false,
           },
           fieldName: oneToManyRelationshipInfo.fieldName,
           name: "oneToManyRelation",
@@ -147,6 +156,7 @@ describe("row api - postgres", () => {
           type: FieldType.LINK,
           constraints: {
             type: "array",
+            presence: false,
           },
           fieldName: manyToOneRelationshipInfo.fieldName,
           name: "manyToOneRelation",
@@ -158,6 +168,7 @@ describe("row api - postgres", () => {
           type: FieldType.LINK,
           constraints: {
             type: "array",
+            presence: false,
           },
           fieldName: manyToManyRelationshipInfo.fieldName,
           name: "manyToManyRelation",
@@ -298,6 +309,9 @@ describe("row api - postgres", () => {
         id: {
           name: "id",
           type: FieldType.AUTO,
+          constraints: {
+            presence: true,
+          },
         },
       },
       sourceId: postgresDatasource._id,
@@ -907,55 +921,47 @@ describe("row api - postgres", () => {
             foreignRows,
             x => x.relationshipType
           )
-          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]: [
+          expect(res.body).toEqual({
+            ...rowData,
+            [`fk_${oneToManyRelationshipInfo.table.name}_${oneToManyRelationshipInfo.fieldName}`]:
+              foreignRowsByType[RelationshipTypes.ONE_TO_MANY][0].row.id,
+            [oneToManyRelationshipInfo.fieldName]: [
               {
-                _id: row._id,
+                ...foreignRowsByType[RelationshipTypes.ONE_TO_MANY][0].row,
+                _id: expect.any(String),
+                _rev: expect.any(String),
               },
             ],
-          })
-          expect(m2mRow2).toEqual({
-            ...foreignRowsByType[RelationshipTypes.MANY_TO_MANY][1].row,
-            [m2mFieldName]: [
+            [manyToOneRelationshipInfo.fieldName]: [
+              {
+                ...foreignRowsByType[RelationshipTypes.MANY_TO_ONE][0].row,
+                [`fk_${manyToOneRelationshipInfo.table.name}_${manyToOneRelationshipInfo.fieldName}`]:
+                  row.id,
+              },
               {
-                _id: 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,
+              },
+            ],
+            [manyToManyRelationshipInfo.fieldName]: [
+              {
+                ...foreignRowsByType[RelationshipTypes.MANY_TO_MANY][0].row,
+              },
+              {
+                ...foreignRowsByType[RelationshipTypes.MANY_TO_MANY][1].row,
               },
             ],
+            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.quit()
+    return this.client.disconnect()
   }
 
   async redisContext(query: Function) {

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

@@ -39,10 +39,6 @@ describe("Google Sheets Integration", () => {
     config.setGoogleAuth("test")
   })
 
-  afterAll(async () => {
-    await config.end()
-  })
-
   beforeEach(async () => {
     integration = new GoogleSheetsIntegration.integration({
       spreadsheetId: "randomId",
@@ -103,8 +99,8 @@ describe("Google Sheets Integration", () => {
       })
     })
 
-    test("removing an existing field will remove the header from the google sheet", async () => {
-      const sheet = await config.doInContext(structures.uuid(), async () => {
+    test("removing an existing field will not remove the data from the spreadsheet", async () => {
+      await config.doInContext(structures.uuid(), async () => {
         const tableColumns = ["name"]
         const table = createBasicTable(structures.uuid(), tableColumns)
 
@@ -113,14 +109,18 @@ describe("Google Sheets Integration", () => {
         })
         sheetsByTitle[table.name] = sheet
         await integration.updateTable(table)
-        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)
+        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)
+      })
     })
   })
 })

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)
-    // have to kill the basic integration before replacing it
-    this.integration.client.quit()
-    this.integration.client = new Redis({
+    this.redis = new Redis({
       data: {
         test: "test",
         result: "1",
       },
     })
+    this.integration.client = this.redis
   }
 }
 
@@ -24,17 +24,13 @@ 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.integration.client.get("key")).toEqual("value")
+    expect(await config.redis.get("key")).toEqual("value")
   })
 
   it("calls the read method with the correct params", async () => {
@@ -50,7 +46,7 @@ describe("Redis Integration", () => {
       key: "test",
     }
     await config.integration.delete(body)
-    expect(await config.integration.client.get(body.key)).toEqual(null)
+    expect(await config.redis.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 { UserCtx } from "@budibase/types"
+import { BBContext } from "@budibase/types"
 
-export default async (ctx: UserCtx, next: any) => {
+export default async (ctx: BBContext, 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,10 +9,7 @@ import { isEqual } from "lodash"
 
 export function combineMetadataAndUser(user: any, metadata: any) {
   // skip users with no access
-  if (
-    user.roleId == null ||
-    user.roleId === rolesCore.BUILTIN_ROLE_IDS.PUBLIC
-  ) {
+  if (user.roleId === rolesCore.BUILTIN_ROLE_IDS.PUBLIC) {
     return null
   }
   delete user._rev

package/src/tests/jestEnv.ts

@@ -9,4 +9,3 @@ 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, timers } from "@budibase/backend-core"
+import { env as coreEnv } from "@budibase/backend-core"
 import { testContainerUtils } from "@budibase/backend-core/tests"
 
 if (!process.env.DEBUG) {
@@ -17,7 +17,3 @@ if (!process.env.CI) {
 }
 
 testContainerUtils.setupEnv(env, coreEnv)
-
-afterAll(() => {
-  timers.cleanup()
-})

package/src/tests/utilities/TestConfiguration.ts

@@ -46,7 +46,6 @@ import {
   Row,
   SourceName,
   Table,
-  SearchFilters,
 } from "@budibase/types"
 
 type DefaultUserValues = {
@@ -165,8 +164,6 @@ class TestConfiguration {
     }
     if (this.server) {
       this.server.close()
-    } else {
-      require("../../app").default.close()
     }
     if (this.allApps) {
       cleanup(this.allApps.map(app => app.appId))
@@ -571,16 +568,6 @@ 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(appId?: string) {
+export function basicAutomation() {
   return {
     name: "My Automation",
     screenId: "kasdkfldsafkl",
@@ -114,23 +114,11 @@ export function basicAutomation(appId?: string) {
     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 { UserCtx, ContextUser, User, UserGroup } from "@budibase/types"
+import { BBContext, ContextUser, User } from "@budibase/types"
 
 export function updateAppRole(
   user: ContextUser,
@@ -43,40 +43,33 @@ export function updateAppRole(
 
 async function checkGroupRoles(
   user: ContextUser,
-  opts: { appId?: string; groups?: UserGroup[] } = {}
+  { appId }: { appId?: string } = {}
 ) {
   if (user.roleId && user.roleId !== roles.BUILTIN_ROLE_IDS.PUBLIC) {
     return user
   }
-  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
+  if (appId) {
+    user.roleId = await groups.getGroupRoleId(user as User, appId)
   }
   return user
 }
 
 async function processUser(
   user: ContextUser,
-  opts: { appId?: string; groups?: UserGroup[] } = {}
+  { appId }: { appId?: string } = {}
 ) {
   if (user) {
     delete user.password
   }
-  const appId = opts.appId || context.getAppId()
-  user = updateAppRole(user, { appId })
+  user = await updateAppRole(user, { appId })
   if (!user.roleId && user?.userGroups?.length) {
-    user = await checkGroupRoles(user, { appId, groups: opts?.groups })
+    user = await checkGroupRoles(user, { appId })
   }
 
   return user
 }
 
-export async function getCachedSelf(ctx: UserCtx, appId: string) {
+export async function getCachedSelf(ctx: BBContext, 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!)
@@ -97,7 +90,6 @@ 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 =>
@@ -126,11 +118,7 @@ export async function getGlobalUsers(users?: ContextUser[]) {
     return globalUsers
   }
 
-  // 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 }))
-  )
+  return globalUsers.map(user => updateAppRole(user))
 }
 
 export async function getGlobalUsersFromMetadata(users: ContextUser[]) {