@budibase/server 2.4.42-alpha.8 → 2.4.43

package/src/automations/automationUtils.ts

@@ -23,7 +23,7 @@ import { LoopStep, LoopStepType, LoopInput } from "../definitions/automations"
  * @returns {object} The inputs object which has had all the various types supported by this function converted to their
  * primitive types.
  */
-export function cleanInputValues(inputs: Record<string, any>, schema?: any) {
+export function cleanInputValues(inputs: Record<string, any>, schema: any) {
   if (schema == null) {
     return inputs
   }

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/db/defaultData/datasource_bb_default.ts

@@ -34,7 +34,7 @@ function syncLastIds(table: Table, rowCount: number) {
   })
 }
 
-function tableImport(table: Table, data: Row[]) {
+function tableImport(table: Table, data: Row) {
   const cloneTable = cloneDeep(table)
   const rowDocs = importToRows(data, cloneTable)
   syncLastIds(cloneTable, rowDocs.length)

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/integrations/googlesheets.ts

@@ -245,10 +245,6 @@ class GoogleSheetsIntegration implements DatasourcePlus {
   }
 
   async buildSchema(datasourceId: string, entities: Record<string, Table>) {
-    // not fully configured yet
-    if (!this.config.auth) {
-      return
-    }
     await this.connect()
     const sheets = this.client.sheetsByIndex
     const tables: Record<string, Table> = {}

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",

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

@@ -2,6 +2,7 @@ import {
   utils,
   constants,
   roles,
+  db as dbCore,
   tenancy,
   context,
 } from "@budibase/backend-core"
@@ -9,15 +10,34 @@ 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)
-  if (!requestAppId) {
+  // get app cookie if it exists
+  let appCookie: { appId?: string } | undefined
+  try {
+    appCookie = utils.getCookie(ctx, constants.Cookie.CurrentApp)
+  } catch (err) {
+    utils.clearCookie(ctx, constants.Cookie.CurrentApp)
+  }
+  if (!appCookie && !requestAppId) {
     return next()
   }
 
+  // check the app exists referenced in cookie
+  if (appCookie) {
+    const appId = appCookie.appId
+    const exists = await dbCore.dbExists(appId)
+    if (!exists) {
+      utils.clearCookie(ctx, constants.Cookie.CurrentApp)
+      return next()
+    }
+    // if the request app ID wasn't set, update it with the cookie
+    requestAppId = requestAppId || appId
+  }
+
   // deny access to application preview
   if (!env.isTest()) {
     if (
@@ -25,6 +45,7 @@ export default async (ctx: UserCtx, next: any) => {
       !isWebhookEndpoint(ctx) &&
       (!ctx.user || !ctx.user.builder || !ctx.user.builder.global)
     ) {
+      utils.clearCookie(ctx, constants.Cookie.CurrentApp)
       return ctx.redirect("/")
     }
   }
@@ -106,6 +127,14 @@ export default async (ctx: UserCtx, next: any) => {
         role: await roles.getRole(roleId),
       }
     }
+    if (
+      (requestAppId !== appId ||
+        appCookie == null ||
+        appCookie.appId !== requestAppId) &&
+      !skipCookie
+    ) {
+      utils.setCookie(ctx, { appId }, constants.Cookie.CurrentApp)
+    }
 
     return next()
   })

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

@@ -158,22 +158,27 @@ describe("Current app middleware", () => {
   })
 
   describe("check functionality when logged in", () => {
-    async function checkExpected() {
+    async function checkExpected(setCookie) {
       config.setUser()
       await config.executeMiddleware()
-
+      let { utils } = require("@budibase/backend-core")
+      if (setCookie) {
+        expect(utils.setCookie).toHaveBeenCalled()
+      } else {
+        expect(utils.setCookie).not.toHaveBeenCalled()
+      }
       expect(config.ctx.roleId).toEqual("PUBLIC")
       expect(config.ctx.user.role._id).toEqual("PUBLIC")
       expect(config.ctx.appId).toEqual("app_test")
       expect(config.next).toHaveBeenCalled()
     }
 
-    it("should be able to setup an app token on a first call", async () => {
+    it("should be able to setup an app token when cookie not setup", async () => {
       mockAuthWithCookie()
-      await checkExpected()
+      await checkExpected(true)
     })
 
-    it("should perform correct on a first call", async () => {
+    it("should perform correct when no cookie exists", async () => {
       mockReset()
       jest.mock("@budibase/backend-core", () => {
         const core = jest.requireActual("@budibase/backend-core")
@@ -201,7 +206,38 @@ describe("Current app middleware", () => {
           },
         }
       })
-      await checkExpected()
+      await checkExpected(true)
+    })
+
+    it("lastly check what occurs when cookie doesn't need updated", async () => {
+      mockReset()
+      jest.mock("@budibase/backend-core", () => {
+        const core = jest.requireActual("@budibase/backend-core")
+        return {
+          ...core,
+          db: {
+            ...core.db,
+            dbExists: () => true,
+          },
+          utils: {
+            getAppIdFromCtx: () => {
+              return "app_test"
+            },
+            setCookie: jest.fn(),
+            getCookie: () => ({ appId: "app_test", roleId: "PUBLIC" }),
+          },
+          cache: {
+            user: {
+              getUser: async id => {
+                return {
+                  _id: "us_uuid1",
+                }
+              },
+            },
+          },
+        }
+      })
+      await checkExpected(false)
     })
   })
 })

package/src/sdk/users/utils.ts

@@ -6,33 +6,22 @@ import {
   InternalTables,
 } from "../../db/utils"
 import { isEqual } from "lodash"
-import { ContextUser, UserMetadata } from "@budibase/types"
 
-export function combineMetadataAndUser(
-  user: ContextUser,
-  metadata: UserMetadata | UserMetadata[]
-) {
-  const metadataId = generateUserMetadataID(user._id!)
-  const found = Array.isArray(metadata)
-    ? metadata.find(doc => doc._id === metadataId)
-    : metadata
+export function combineMetadataAndUser(user: any, metadata: any) {
   // skip users with no access
-  if (
-    user.roleId == null ||
-    user.roleId === rolesCore.BUILTIN_ROLE_IDS.PUBLIC
-  ) {
-    // If it exists and it should not, we must remove it
-    if (found?._id) {
-      return { ...found, _deleted: true }
-    }
+  if (user.roleId === rolesCore.BUILTIN_ROLE_IDS.PUBLIC) {
     return null
   }
   delete user._rev
+  const metadataId = generateUserMetadataID(user._id)
   const newDoc = {
     ...user,
     _id: metadataId,
     tableId: InternalTables.USER_METADATA,
   }
+  const found = Array.isArray(metadata)
+    ? metadata.find(doc => doc._id === metadataId)
+    : metadata
   // copy rev over for the purposes of equality check
   if (found) {
     newDoc._rev = found._rev
@@ -66,7 +55,7 @@ export async function syncGlobalUsers() {
   ])
   const toWrite = []
   for (let user of users) {
-    const combined = combineMetadataAndUser(user, metadata)
+    const combined = await combineMetadataAndUser(user, metadata)
     if (combined) {
       toWrite.push(combined)
     }

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

@@ -47,7 +47,6 @@ import {
   SourceName,
   Table,
   SearchFilters,
-  UserRoles,
 } from "@budibase/types"
 
 type DefaultUserValues = {
@@ -166,8 +165,6 @@ class TestConfiguration {
     }
     if (this.server) {
       this.server.close()
-    } else {
-      require("../../app").default.close()
     }
     if (this.allApps) {
       cleanup(this.allApps.map(app => app.appId))
@@ -278,7 +275,7 @@ class TestConfiguration {
       email?: string
       builder?: boolean
       admin?: boolean
-      roles?: UserRoles
+      roles?: any
     } = {}
   ) {
     let { id, firstName, lastName, email, builder, admin, roles } = user
@@ -331,13 +328,21 @@ class TestConfiguration {
         sessionId: "sessionid",
         tenantId: this.getTenantId(),
       }
+      const app = {
+        roleId: roleId,
+        appId,
+      }
       const authToken = auth.jwt.sign(authObj, coreEnv.JWT_SECRET)
+      const appToken = auth.jwt.sign(app, coreEnv.JWT_SECRET)
 
       // returning necessary request headers
       await cache.user.invalidateUser(userId)
       return {
         Accept: "application/json",
-        Cookie: [`${constants.Cookie.Auth}=${authToken}`],
+        Cookie: [
+          `${constants.Cookie.Auth}=${authToken}`,
+          `${constants.Cookie.CurrentApp}=${appToken}`,
+        ],
         [constants.Header.APP_ID]: appId,
       }
     })
@@ -352,11 +357,18 @@ class TestConfiguration {
       sessionId: "sessionid",
       tenantId,
     }
+    const app = {
+      roleId: roles.BUILTIN_ROLE_IDS.ADMIN,
+      appId: this.appId,
+    }
     const authToken = auth.jwt.sign(authObj, coreEnv.JWT_SECRET)
-
+    const appToken = auth.jwt.sign(app, coreEnv.JWT_SECRET)
     const headers: any = {
       Accept: "application/json",
-      Cookie: [`${constants.Cookie.Auth}=${authToken}`],
+      Cookie: [
+        `${constants.Cookie.Auth}=${authToken}`,
+        `${constants.Cookie.CurrentApp}=${appToken}`,
+      ],
       [constants.Header.CSRF_TOKEN]: this.defaultUserValues.csrfToken,
       Host: this.tenantHost(),
       ...extras,

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/fileSystem/filesystem.ts

@@ -24,10 +24,6 @@ export const init = () => {
       }
     }
   }
-  const clientLibPath = join(budibaseTempDir(), "budibase-client.js")
-  if (env.isTest() && !fs.existsSync(clientLibPath)) {
-    fs.copyFileSync(require.resolve("@budibase/client"), clientLibPath)
-  }
 }
 
 /**

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[]) {

package/src/utilities/rowProcessor/index.ts

@@ -131,7 +131,7 @@ export function coerce(row: any, type: string) {
  * @returns {object} the row which has been prepared to be written to the DB.
  */
 export function inputProcessing(
-  user: ContextUser | null,
+  user: ContextUser,
   table: Table,
   row: Row,
   opts?: AutoColumnProcessingOpts