@budibase/server 2.1.32-alpha.8 → 2.1.32

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")
   })

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

@@ -1,16 +1,11 @@
-jest.mock("@budibase/backend-core", () => {
-  const core = jest.requireActual("@budibase/backend-core")
-  return {
-    ...core,
-    db: {
-      ...core.db,
-      createNewUserEmailView: jest.fn()
-    }
-  }
-})
-const { tenancy, db: dbCore } = require("@budibase/backend-core")
+jest.mock("@budibase/backend-core/db", () => ({
+  ...jest.requireActual("@budibase/backend-core/db"),
+  createNewUserEmailView: jest.fn(),
+}))
+const coreDb = require("@budibase/backend-core/db")
 const TestConfig = require("../../../tests/utilities/TestConfiguration")
 const { TENANT_ID } = require("../../../tests/utilities/structures")
+const { getGlobalDB, doInTenant } = require("@budibase/backend-core/tenancy")
 
 // mock email view creation
 
@@ -26,10 +21,10 @@ describe("run", () => {
     afterAll(config.end)
 
     it("runs successfully", async () => {
-      await tenancy.doInTenant(TENANT_ID, async () => {
-        const globalDb = tenancy.getGlobalDB()
+      await doInTenant(TENANT_ID, async () => {
+        const globalDb = getGlobalDB()
         await migration.run(globalDb)
-        expect(dbCore.createNewUserEmailView).toHaveBeenCalledTimes(1)
+        expect(coreDb.createNewUserEmailView).toHaveBeenCalledTimes(1)
       })
     })
 })

package/src/migrations/functions/usageQuotas/syncApps.ts

@@ -1,14 +1,15 @@
-import { tenancy, db as dbCore } from "@budibase/backend-core"
+import { getTenantId } from "@budibase/backend-core/tenancy"
+import { getAllApps } from "@budibase/backend-core/db"
 import { quotas } from "@budibase/pro"
 import { QuotaUsageType, StaticQuotaName } from "@budibase/types"
 
 export const run = async () => {
   // get app count
-  const devApps = await dbCore.getAllApps({ dev: true })
+  const devApps = await getAllApps({ dev: true })
   const appCount = devApps ? devApps.length : 0
 
   // sync app count
-  const tenantId = tenancy.getTenantId()
+  const tenantId = getTenantId()
   console.log(`[Tenant: ${tenantId}] Syncing app count: ${appCount}`)
   await quotas.setUsage(appCount, StaticQuotaName.APPS, QuotaUsageType.STATIC)
 }

package/src/migrations/functions/usageQuotas/syncRows.ts

@@ -1,11 +1,12 @@
-import { tenancy, db as dbCore } from "@budibase/backend-core"
+import { getTenantId } from "@budibase/backend-core/tenancy"
+import { getAllApps } from "@budibase/backend-core/db"
 import { getUniqueRows } from "../../../utilities/usageQuota/rows"
 import { quotas } from "@budibase/pro"
-import { StaticQuotaName, QuotaUsageType, App } from "@budibase/types"
+import { StaticQuotaName, QuotaUsageType } from "@budibase/types"
 
 export const run = async () => {
   // get all rows in all apps
-  const allApps = (await dbCore.getAllApps({ all: true })) as App[]
+  const allApps = await getAllApps({ all: true })
   const appIds = allApps ? allApps.map((app: { appId: any }) => app.appId) : []
   const { appRows } = await getUniqueRows(appIds)
 
@@ -18,7 +19,7 @@ export const run = async () => {
   })
 
   // sync row count
-  const tenantId = tenancy.getTenantId()
+  const tenantId = getTenantId()
   console.log(`[Tenant: ${tenantId}] Syncing row count: ${rowCount}`)
   await quotas.setUsagePerApp(
     counts,

package/src/migrations/functions/usageQuotas/tests/syncRows.spec.ts

@@ -2,7 +2,7 @@ import TestConfig from "../../../../tests/utilities/TestConfiguration"
 import * as syncRows from "../syncRows"
 import { quotas } from "@budibase/pro"
 import { QuotaUsageType, StaticQuotaName } from "@budibase/types"
-const { db: dbCore } = require("@budibase/backend-core")
+const { getProdAppID } = require("@budibase/backend-core/db")
 
 describe("syncRows", () => {
   let config = new TestConfig(false)
@@ -38,12 +38,12 @@ describe("syncRows", () => {
       // assert the migration worked
       usageDoc = await quotas.getQuotaUsage()
       expect(usageDoc.usageQuota.rows).toEqual(3)
-      expect(
-        usageDoc.apps?.[dbCore.getProdAppID(app1.appId)].usageQuota.rows
-      ).toEqual(1)
-      expect(
-        usageDoc.apps?.[dbCore.getProdAppID(app2.appId)].usageQuota.rows
-      ).toEqual(2)
+      expect(usageDoc.apps?.[getProdAppID(app1.appId)].usageQuota.rows).toEqual(
+        1
+      )
+      expect(usageDoc.apps?.[getProdAppID(app2.appId)].usageQuota.rows).toEqual(
+        2
+      )
     })
   })
 })

package/src/migrations/functions/userEmailViewCasing.ts

@@ -1,4 +1,4 @@
-import { db as dbCore } from "@budibase/backend-core"
+const { createNewUserEmailView } = require("@budibase/backend-core/db")
 
 /**
  * Date:
@@ -8,6 +8,6 @@ import { db as dbCore } from "@budibase/backend-core"
  * Recreate the user email view to include latest changes i.e. lower casing the email address
  */
 
-export const run = async () => {
-  await dbCore.createNewUserEmailView()
+export const run = async (db: any) => {
+  await createNewUserEmailView(db)
 }

package/src/module.d.ts

@@ -0,0 +1,14 @@
+declare module "@budibase/backend-core/tenancy"
+declare module "@budibase/backend-core/db"
+declare module "@budibase/backend-core/context"
+declare module "@budibase/backend-core/cache"
+declare module "@budibase/backend-core/permissions"
+declare module "@budibase/backend-core/roles"
+declare module "@budibase/backend-core/constants"
+declare module "@budibase/backend-core/auth"
+declare module "@budibase/backend-core/sessions"
+declare module "@budibase/backend-core/encryption"
+declare module "@budibase/backend-core/utils"
+declare module "@budibase/backend-core/redis"
+declare module "@budibase/backend-core/objectStore"
+declare module "@budibase/backend-core/plugins"

package/src/sdk/app/backups/exports.ts

@@ -1,5 +1,6 @@
-import { db as dbCore, objectStore } from "@budibase/backend-core"
+import { db as dbCore } from "@budibase/backend-core"
 import { budibaseTempDir } from "../../../utilities/budibaseDir"
+import { retrieveDirectory } from "../../../utilities/fileSystem/utilities"
 import { streamFile, createTempFolder } from "../../../utilities/fileSystem"
 import { ObjectStoreBuckets } from "../../../constants"
 import {
@@ -87,10 +88,7 @@ export async function exportApp(appId: string, config?: ExportOpts) {
   // export bucket contents
   let tmpPath
   if (!env.isTest()) {
-    tmpPath = await objectStore.retrieveDirectory(
-      ObjectStoreBuckets.APPS,
-      appPath
-    )
+    tmpPath = await retrieveDirectory(ObjectStoreBuckets.APPS, appPath)
   } else {
     tmpPath = createTempFolder(uuid())
   }