@budibase/server 2.1.43-alpha.6 → 2.1.44

package/src/middleware/{currentapp.ts → currentapp.js}

@@ -1,26 +1,29 @@
-import {
-  utils,
-  constants,
-  roles,
-  db as dbCore,
-  tenancy,
-  context,
-} from "@budibase/backend-core"
-import { generateUserMetadataID, isDevAppID } from "../db/utils"
-import { getCachedSelf } from "../utilities/global"
-import env from "../environment"
-import { isWebhookEndpoint } from "./utils"
-import { BBContext } from "@budibase/types"
+const {
+  getAppIdFromCtx,
+  setCookie,
+  getCookie,
+  clearCookie,
+} = require("@budibase/backend-core/utils")
+const { Cookies, Headers } = require("@budibase/backend-core/constants")
+const { getRole } = require("@budibase/backend-core/roles")
+const { BUILTIN_ROLE_IDS } = require("@budibase/backend-core/roles")
+const { generateUserMetadataID, isDevAppID } = require("../db/utils")
+const { dbExists } = require("@budibase/backend-core/db")
+const { isUserInAppTenant } = require("@budibase/backend-core/tenancy")
+const { getCachedSelf } = require("../utilities/global")
+const env = require("../environment")
+const { isWebhookEndpoint } = require("./utils")
+const { doInAppContext } = require("@budibase/backend-core/context")
 
-export = async (ctx: BBContext, next: any) => {
+module.exports = async (ctx, next) => {
   // try to get the appID from the request
-  let requestAppId = await utils.getAppIdFromCtx(ctx)
+  let requestAppId = await getAppIdFromCtx(ctx)
   // get app cookie if it exists
-  let appCookie: { appId?: string } | undefined
+  let appCookie = null
   try {
-    appCookie = utils.getCookie(ctx, constants.Cookie.CurrentApp)
+    appCookie = getCookie(ctx, Cookies.CurrentApp)
   } catch (err) {
-    utils.clearCookie(ctx, constants.Cookie.CurrentApp)
+    clearCookie(ctx, Cookies.CurrentApp)
   }
   if (!appCookie && !requestAppId) {
     return next()
@@ -28,9 +31,9 @@ export = async (ctx: BBContext, next: any) => {
   // check the app exists referenced in cookie
   if (appCookie) {
     const appId = appCookie.appId
-    const exists = await dbCore.dbExists(appId)
+    const exists = await dbExists(appId)
     if (!exists) {
-      utils.clearCookie(ctx, constants.Cookie.CurrentApp)
+      clearCookie(ctx, Cookies.CurrentApp)
       return next()
     }
     // if the request app ID wasn't set, update it with the cookie
@@ -44,13 +47,13 @@ export = async (ctx: BBContext, next: any) => {
       !isWebhookEndpoint(ctx) &&
       (!ctx.user || !ctx.user.builder || !ctx.user.builder.global)
     ) {
-      utils.clearCookie(ctx, constants.Cookie.CurrentApp)
+      clearCookie(ctx, Cookies.CurrentApp)
       return ctx.redirect("/")
     }
   }
 
-  let appId: string | undefined,
-    roleId = roles.BUILTIN_ROLE_IDS.PUBLIC
+  let appId,
+    roleId = BUILTIN_ROLE_IDS.PUBLIC
   if (!ctx.user) {
     // not logged in, try to set a cookie for public apps
     appId = requestAppId
@@ -65,20 +68,16 @@ export = async (ctx: BBContext, next: any) => {
     const isBuilder =
       globalUser && globalUser.builder && globalUser.builder.global
     const isDevApp = appId && isDevAppID(appId)
-    const roleHeader =
-      ctx.request &&
-      (ctx.request.headers[constants.Header.PREVIEW_ROLE] as string)
+    const roleHeader = ctx.request && ctx.request.headers[Headers.PREVIEW_ROLE]
     if (isBuilder && isDevApp && roleHeader) {
       // Ensure the role is valid by ensuring a definition exists
       try {
-        if (roleHeader) {
-          await roles.getRole(roleHeader)
-          roleId = roleHeader
+        await getRole(roleHeader)
+        roleId = roleHeader
 
-          // Delete admin and builder flags so that the specified role is honoured
-          delete ctx.user.builder
-          delete ctx.user.admin
-        }
+        // Delete admin and builder flags so that the specified role is honoured
+        delete ctx.user.builder
+        delete ctx.user.admin
       } catch (error) {
         // Swallow error and do nothing
       }
@@ -90,7 +89,7 @@ export = async (ctx: BBContext, next: any) => {
     return next()
   }
 
-  return context.doInAppContext(appId, async () => {
+  return doInAppContext(appId, async () => {
     let skipCookie = false
     // if the user not in the right tenant then make sure they have no permissions
     // need to judge this only based on the request app ID,
@@ -98,14 +97,14 @@ export = async (ctx: BBContext, next: any) => {
       env.MULTI_TENANCY &&
       ctx.user &&
       requestAppId &&
-      !tenancy.isUserInAppTenant(requestAppId, ctx.user)
+      !isUserInAppTenant(requestAppId, ctx.user)
     ) {
       // don't error, simply remove the users rights (they are a public user)
       delete ctx.user.builder
       delete ctx.user.admin
       delete ctx.user.roles
       ctx.isAuthenticated = false
-      roleId = roles.BUILTIN_ROLE_IDS.PUBLIC
+      roleId = BUILTIN_ROLE_IDS.PUBLIC
       skipCookie = true
     }
 
@@ -113,17 +112,15 @@ export = async (ctx: BBContext, next: any) => {
     if (roleId) {
       ctx.roleId = roleId
       const globalId = ctx.user ? ctx.user._id : undefined
-      const userId = ctx.user
-        ? generateUserMetadataID(ctx.user._id!)
-        : undefined
+      const userId = ctx.user ? generateUserMetadataID(ctx.user._id) : null
       ctx.user = {
-        ...ctx.user!,
+        ...ctx.user,
         // override userID with metadata one
         _id: userId,
         userId,
         globalId,
         roleId,
-        role: await roles.getRole(roleId),
+        role: await getRole(roleId),
       }
     }
     if (
@@ -132,7 +129,7 @@ export = async (ctx: BBContext, next: any) => {
         appCookie.appId !== requestAppId) &&
       !skipCookie
     ) {
-      utils.setCookie(ctx, { appId }, constants.Cookie.CurrentApp)
+      setCookie(ctx, { appId }, Cookies.CurrentApp)
     }
 
     return next()

package/src/middleware/{joi-validator.ts → joi-validator.js}

@@ -1,21 +1,20 @@
-import Joi from "joi"
-import { BBContext } from "@budibase/types"
+const Joi = require("joi")
 
-function validate(schema: Joi.Schema, property: string) {
+function validate(schema, property) {
   // Return a Koa middleware function
-  return (ctx: BBContext, next: any) => {
+  return (ctx, next) => {
     if (!schema) {
       return next()
     }
     let params = null
     if (ctx[property] != null) {
       params = ctx[property]
-    } else if (ctx.request.get(property) != null) {
-      params = ctx.request.get(property)
+    } else if (ctx.request[property] != null) {
+      params = ctx.request[property]
     }
 
     // not all schemas have the append property e.g. array schemas
-    if ("append" in schema && schema.append) {
+    if (schema.append) {
       schema = schema.append({
         createdAt: Joi.any().optional(),
         updatedAt: Joi.any().optional(),
@@ -31,10 +30,10 @@ function validate(schema: Joi.Schema, property: string) {
   }
 }
 
-export function body(schema: Joi.Schema) {
+module.exports.body = schema => {
   return validate(schema, "body")
 }
 
-export function params(schema: Joi.Schema) {
+module.exports.params = schema => {
   return validate(schema, "params")
 }

package/src/middleware/publicApi.js

@@ -0,0 +1,21 @@
+const { Headers } = require("@budibase/backend-core/constants")
+const { getAppIdFromCtx } = require("@budibase/backend-core/utils")
+
+module.exports = function ({ requiresAppId } = {}) {
+  return async (ctx, next) => {
+    const appId = await getAppIdFromCtx(ctx)
+    if (requiresAppId && !appId) {
+      ctx.throw(
+        400,
+        `Invalid app ID provided, please check the ${Headers.APP_ID} header.`
+      )
+    }
+    if (!ctx.headers[Headers.API_KEY]) {
+      ctx.throw(
+        400,
+        `Invalid API key provided, please check the ${Headers.API_KEY} header.`
+      )
+    }
+    return next()
+  }
+}

package/src/middleware/{resourceId.ts → resourceId.js}

@@ -1,23 +1,17 @@
-import { BBContext } from "@budibase/types"
-
-export class ResourceIdGetter {
-  parameter: string
-  main: string | null
-  sub: string | null
-
-  constructor(ctxProperty: string) {
+class ResourceIdGetter {
+  constructor(ctxProperty) {
     this.parameter = ctxProperty
     this.main = null
     this.sub = null
     return this
   }
 
-  mainResource(field: string) {
+  mainResource(field) {
     this.main = field
     return this
   }
 
-  subResource(field: string) {
+  subResource(field) {
     this.sub = field
     return this
   }
@@ -26,8 +20,7 @@ export class ResourceIdGetter {
     const parameter = this.parameter,
       main = this.main,
       sub = this.sub
-    return (ctx: BBContext, next: any) => {
-      // @ts-ignore
+    return (ctx, next) => {
       const request = ctx.request[parameter] || ctx[parameter]
       if (request == null) {
         return next()
@@ -43,22 +36,24 @@ export class ResourceIdGetter {
   }
 }
 
-export function paramResource(main: string) {
+module.exports.ResourceIdGetter = ResourceIdGetter
+
+module.exports.paramResource = main => {
   return new ResourceIdGetter("params").mainResource(main).build()
 }
 
-export function paramSubResource(main: string, sub: string) {
+module.exports.paramSubResource = (main, sub) => {
   return new ResourceIdGetter("params")
     .mainResource(main)
     .subResource(sub)
     .build()
 }
 
-export function bodyResource(main: string) {
+module.exports.bodyResource = main => {
   return new ResourceIdGetter("body").mainResource(main).build()
 }
 
-export function bodySubResource(main: string, sub: string) {
+module.exports.bodySubResource = (main, sub) => {
   return new ResourceIdGetter("body")
     .mainResource(main)
     .subResource(sub)

package/src/middleware/{selfhost.ts → selfhost.js}

@@ -1,9 +1,7 @@
-import env from "../environment"
-import { BBContext } from "@budibase/types"
-
+const env = require("../environment")
 // if added as a middleware will stop requests unless builder is in self host mode
 // or cloud is in self host
-export = async (ctx: BBContext, next: any) => {
+module.exports = async (ctx, next) => {
   if (env.SELF_HOSTED) {
     await next()
     return

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

@@ -9,7 +9,8 @@ jest.mock("../../environment", () => ({
 )
 const authorizedMiddleware = require("../authorized")
 const env = require("../../environment")
-const { permissions } = require("@budibase/backend-core")
+const { PermissionTypes, PermissionLevels } = require("@budibase/backend-core/permissions")
+const { doInAppContext } = require("@budibase/backend-core/context")
 
 const APP_ID = ""
 
@@ -112,7 +113,7 @@ describe("Authorization middleware", () => {
     
     it("throws if the user does not have builder permissions", async () => {
       config.setEnvironment(false)
-      config.setMiddlewareRequiredPermission(permissions.PermissionType.BUILDER)
+      config.setMiddlewareRequiredPermission(PermissionTypes.BUILDER)
       config.setUser({
         role: {
           _id: ""
@@ -124,13 +125,13 @@ describe("Authorization middleware", () => {
     })
 
     it("passes on to next() middleware if the user has resource permission", async () => {
-      config.setResourceId(permissions.PermissionType.QUERY)
+      config.setResourceId(PermissionTypes.QUERY)
       config.setUser({
         role: {
           _id: ""
         }
       })
-      config.setMiddlewareRequiredPermission(permissions.PermissionType.QUERY)
+      config.setMiddlewareRequiredPermission(PermissionTypes.QUERY)
 
       await config.executeMiddleware()
       expect(config.next).toHaveBeenCalled()
@@ -154,7 +155,7 @@ describe("Authorization middleware", () => {
           _id: ""
         },
       })
-      config.setMiddlewareRequiredPermission(permissions.PermissionType.ADMIN, permissions.PermissionLevel.BASIC)
+      config.setMiddlewareRequiredPermission(PermissionTypes.ADMIN, PermissionLevels.BASIC)
       
       await config.executeMiddleware()
       expect(config.throw).toHaveBeenCalledWith(403, "User does not have permission")

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

@@ -1,8 +1,16 @@
-require("../../db").init()
 mockAuthWithNoCookie()
 mockWorker()
 mockUserGroups()
 
+jest.mock("@budibase/backend-core/db", () => {
+  const coreDb = jest.requireActual("@budibase/backend-core/db")
+  coreDb.init()
+  return {
+    ...coreDb,
+    dbExists: () => true,
+  }
+})
+
 function mockWorker() {
   jest.mock("../../utilities/workerRequests", () => ({
     getGlobalSelf: () => {
@@ -35,62 +43,42 @@ function mockUserGroups() {
 function mockAuthWithNoCookie() {
   jest.resetModules()
   mockWorker()
-  jest.mock("@budibase/backend-core", () => {
-    const core = jest.requireActual("@budibase/backend-core")
-    return {
-      ...core,
-      db: {
-        ...core.db,
-        dbExists: () => true,
-      },
-      cache: {
-        user: {
-          getUser: async id => {
-            return {
-              _id: "us_uuid1",
-            }
-          },
-        },
-      },
-      utils: {
-        getAppIdFromCtx: jest.fn(),
-        setCookie: jest.fn(),
-        getCookie: jest.fn(),
+  jest.mock("@budibase/backend-core/cache", () => ({
+    user: {
+      getUser: () => {
+        return {
+          _id: "us_uuid1",
+        }
       },
-    }
-  })
+    },
+  }))
+  jest.mock("@budibase/backend-core/utils", () => ({
+    getAppIdFromCtx: jest.fn(),
+    setCookie: jest.fn(),
+    getCookie: jest.fn(),
+  }))
+  jest.mock("@budibase/backend-core/constants", () => ({
+    Cookies: {},
+  }))
 }
 
 function mockAuthWithCookie() {
   jest.resetModules()
   mockWorker()
-  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(),
-        clearCookie: jest.fn(),
-        getCookie: () => ({ appId: "app_different", roleId: "PUBLIC" }),
-      },
-      cache: {
-        user: {
-          getUser: async id => {
-            return {
-              _id: "us_uuid1",
-            }
-          },
-        },
-      },
-    }
-  })
+  jest.mock("@budibase/backend-core/utils", () => ({
+    getAppIdFromCtx: () => {
+      return "app_test"
+    },
+    setCookie: jest.fn(),
+    clearCookie: jest.fn(),
+    getCookie: () => ({appId: "app_different", roleId: "PUBLIC"}),
+  }))
+  jest.mock("@budibase/backend-core/constants", () => ({
+    Cookies: {
+      Auth: "auth",
+      CurrentApp: "currentapp",
+    },
+  }))
 }
 
 class TestConfiguration {
@@ -100,16 +88,7 @@ class TestConfiguration {
 
     this.ctx = {
       next: this.next,
-      throw: this.throw,
-      request: {
-        body: {},
-        headers: {},
-      },
-      headers: {},
-      path: "",
-      cookies: {
-        set: jest.fn(),
-      }
+      throw: this.throw
     }
   }
 
@@ -122,8 +101,6 @@ class TestConfiguration {
 
   executeMiddleware() {
     // import as late as possible for mocks
-    jest.resetModules()
-    require("../../db").init()
     const currentAppMiddleware = require("../currentapp")
     return currentAppMiddleware(this.ctx, this.next)
   }
@@ -161,11 +138,11 @@ describe("Current app middleware", () => {
     async function checkExpected(setCookie) {
       config.setUser()
       await config.executeMiddleware()
-      let { utils } = require("@budibase/backend-core")
+      let { setCookie: cookieFn } = require("@budibase/backend-core/utils")
       if (setCookie) {
-        expect(utils.setCookie).toHaveBeenCalled()
+        expect(cookieFn).toHaveBeenCalled()
       } else {
-        expect(utils.setCookie).not.toHaveBeenCalled()
+        expect(cookieFn).not.toHaveBeenCalled()
       }
       expect(config.ctx.roleId).toEqual("PUBLIC")
       expect(config.ctx.user.role._id).toEqual("PUBLIC")
@@ -180,63 +157,31 @@ describe("Current app middleware", () => {
 
     it("should perform correct when no cookie exists", 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: jest.fn(),
-          },
-          cache: {
-            user: {
-              getUser: async id => {
-                return {
-                  _id: "us_uuid1",
-                }
-              },
-            },
-          },
-        }
-      })
+      jest.mock("@budibase/backend-core/utils", () => ({
+        getAppIdFromCtx: () => {
+          return "app_test"
+        },
+        setCookie: jest.fn(),
+        getCookie: jest.fn(),
+      }))
+      jest.mock("@budibase/backend-core/constants", () => ({
+        Cookies: {},
+      }))
       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",
-                }
-              },
-            },
-          },
-        }
-      })
+      jest.mock("@budibase/backend-core/utils", () => ({
+        getAppIdFromCtx: () => {
+          return "app_test"
+        },
+        setCookie: jest.fn(),
+        getCookie: () => ({appId: "app_test", roleId: "PUBLIC"}),
+      }))
+      jest.mock("@budibase/backend-core/constants", () => ({
+        Cookies: {},
+      }))
       await checkExpected(false)
     })
   })

package/src/middleware/{utils.ts → utils.js}

@@ -1,9 +1,7 @@
-import { BBContext } from "@budibase/types"
-
 const WEBHOOK_ENDPOINTS = new RegExp(
   ["webhooks/trigger", "webhooks/schema"].join("|")
 )
 
-export function isWebhookEndpoint(ctx: BBContext) {
+exports.isWebhookEndpoint = ctx => {
   return WEBHOOK_ENDPOINTS.test(ctx.request.url)
 }

package/src/migrations/functions/appUrls.ts

@@ -1,4 +1,4 @@
-import { db as dbCore } from "@budibase/backend-core"
+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(dbCore.DocumentType.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/tables.ts

@@ -1,8 +1,11 @@
 import { events } from "@budibase/backend-core"
-import { Database } from "@budibase/types"
 import sdk from "../../../../sdk"
+import PouchDB from "pouchdb"
 
-export const backfill = async (appDb: Database, timestamp: string | number) => {
+export const backfill = async (
+  appDb: PouchDB.Database,
+  timestamp: string | number
+) => {
   const tables = await sdk.tables.getAllInternalTables(appDb)
 
   for (const table of tables) {

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

@@ -149,7 +149,7 @@ export const run = async (db: any) => {
     }
 
     try {
-      const allApps = (await dbUtils.getAllApps({ dev: true })) as App[]
+      const allApps: App[] = await dbUtils.getAllApps({ dev: true })
       totals.apps = allApps.length
 
       totals.usage = await quotas.backfill(allApps)

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

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