@budibase/server 2.1.39 → 2.1.40-alpha.1

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

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

package/src/middleware/publicApi.ts

@@ -0,0 +1,21 @@
+import { constants, utils } from "@budibase/backend-core"
+import { BBContext } from "@budibase/types"
+
+export = function ({ requiresAppId }: { requiresAppId?: boolean } = {}) {
+  return async (ctx: BBContext, next: any) => {
+    const appId = await utils.getAppIdFromCtx(ctx)
+    if (requiresAppId && !appId) {
+      ctx.throw(
+        400,
+        `Invalid app ID provided, please check the ${constants.Header.APP_ID} header.`
+      )
+    }
+    if (!ctx.headers[constants.Header.API_KEY]) {
+      ctx.throw(
+        400,
+        `Invalid API key provided, please check the ${constants.Header.API_KEY} header.`
+      )
+    }
+    return next()
+  }
+}

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

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

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

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

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

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

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

@@ -1,16 +1,8 @@
+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: () => {
@@ -43,42 +35,62 @@ function mockUserGroups() {
 function mockAuthWithNoCookie() {
   jest.resetModules()
   mockWorker()
-  jest.mock("@budibase/backend-core/cache", () => ({
-    user: {
-      getUser: () => {
-        return {
-          _id: "us_uuid1",
-        }
+  jest.mock("@budibase/backend-core", () => {
+    const core = jest.requireActual("@budibase/backend-core")
+    return {
+      ...core,
+      db: {
+        ...core.db,
+        dbExists: () => true,
       },
-    },
-  }))
-  jest.mock("@budibase/backend-core/utils", () => ({
-    getAppIdFromCtx: jest.fn(),
-    setCookie: jest.fn(),
-    getCookie: jest.fn(),
-  }))
-  jest.mock("@budibase/backend-core/constants", () => ({
-    Cookies: {},
-  }))
+      cache: {
+        user: {
+          getUser: async id => {
+            return {
+              _id: "us_uuid1",
+            }
+          },
+        },
+      },
+      utils: {
+        getAppIdFromCtx: jest.fn(),
+        setCookie: jest.fn(),
+        getCookie: jest.fn(),
+      },
+    }
+  })
 }
 
 function mockAuthWithCookie() {
   jest.resetModules()
   mockWorker()
-  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",
-    },
-  }))
+  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",
+            }
+          },
+        },
+      },
+    }
+  })
 }
 
 class TestConfiguration {
@@ -88,7 +100,16 @@ class TestConfiguration {
 
     this.ctx = {
       next: this.next,
-      throw: this.throw
+      throw: this.throw,
+      request: {
+        body: {},
+        headers: {},
+      },
+      headers: {},
+      path: "",
+      cookies: {
+        set: jest.fn(),
+      }
     }
   }
 
@@ -101,6 +122,8 @@ 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)
   }
@@ -138,11 +161,11 @@ describe("Current app middleware", () => {
     async function checkExpected(setCookie) {
       config.setUser()
       await config.executeMiddleware()
-      let { setCookie: cookieFn } = require("@budibase/backend-core/utils")
+      let { utils } = require("@budibase/backend-core")
       if (setCookie) {
-        expect(cookieFn).toHaveBeenCalled()
+        expect(utils.setCookie).toHaveBeenCalled()
       } else {
-        expect(cookieFn).not.toHaveBeenCalled()
+        expect(utils.setCookie).not.toHaveBeenCalled()
       }
       expect(config.ctx.roleId).toEqual("PUBLIC")
       expect(config.ctx.user.role._id).toEqual("PUBLIC")
@@ -157,31 +180,63 @@ describe("Current app middleware", () => {
 
     it("should perform correct when no cookie exists", async () => {
       mockReset()
-      jest.mock("@budibase/backend-core/utils", () => ({
-        getAppIdFromCtx: () => {
-          return "app_test"
-        },
-        setCookie: jest.fn(),
-        getCookie: jest.fn(),
-      }))
-      jest.mock("@budibase/backend-core/constants", () => ({
-        Cookies: {},
-      }))
+      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",
+                }
+              },
+            },
+          },
+        }
+      })
       await checkExpected(true)
     })
 
     it("lastly check what occurs when cookie doesn't need updated", async () => {
       mockReset()
-      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: {},
-      }))
+      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/middleware/{utils.js → utils.ts}

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

package/src/migrations/functions/appUrls.ts

@@ -1,4 +1,4 @@
-const { DocumentType } = require("@budibase/backend-core/db")
+import { db as dbCore } from "@budibase/backend-core"
 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(DocumentType.APP_METADATA)
+    metadata = await appDb.get(dbCore.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,11 +1,8 @@
 import { events } from "@budibase/backend-core"
+import { Database } from "@budibase/types"
 import sdk from "../../../../sdk"
-import PouchDB from "pouchdb"
 
-export const backfill = async (
-  appDb: PouchDB.Database,
-  timestamp: string | number
-) => {
+export const backfill = async (appDb: 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: App[] = await dbUtils.getAllApps({ dev: true })
+      const allApps = (await dbUtils.getAllApps({ dev: true })) as App[]
       totals.apps = allApps.length
 
       totals.usage = await quotas.backfill(allApps)

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

@@ -1,4 +1,4 @@
-const {  DocumentType, doWithDB } = require("@budibase/backend-core/db")
+const { db: dbCore } = require("@budibase/backend-core")
 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 doWithDB(app.appId, async db => {
-      const metadataDoc = await db.get( DocumentType.APP_METADATA)
+    const metadata = await dbCore.doWithDB(app.appId, async db => {
+      const metadataDoc = await db.get(dbCore.DocumentType.APP_METADATA)
       delete metadataDoc.url
       await db.put(metadataDoc)
       await migration.run(db)
-      return await db.get( DocumentType.APP_METADATA)
+      return await db.get(dbCore.DocumentType.APP_METADATA)
     })
     expect(metadata.url).toEqual("/testapp")
   })

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

@@ -1,11 +1,16 @@
-jest.mock("@budibase/backend-core/db", () => ({
-  ...jest.requireActual("@budibase/backend-core/db"),
-  createNewUserEmailView: jest.fn(),
-}))
-const coreDb = require("@budibase/backend-core/db")
+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")
 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
 
@@ -21,10 +26,10 @@ describe("run", () => {
     afterAll(config.end)
 
     it("runs successfully", async () => {
-      await doInTenant(TENANT_ID, async () => {
-        const globalDb = getGlobalDB()
+      await tenancy.doInTenant(TENANT_ID, async () => {
+        const globalDb = tenancy.getGlobalDB()
         await migration.run(globalDb)
-        expect(coreDb.createNewUserEmailView).toHaveBeenCalledTimes(1)
+        expect(dbCore.createNewUserEmailView).toHaveBeenCalledTimes(1)
       })
     })
 })

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

@@ -1,15 +1,14 @@
-import { getTenantId } from "@budibase/backend-core/tenancy"
-import { getAllApps } from "@budibase/backend-core/db"
+import { tenancy, db as dbCore } from "@budibase/backend-core"
 import { quotas } from "@budibase/pro"
 import { QuotaUsageType, StaticQuotaName } from "@budibase/types"
 
 export const run = async () => {
   // get app count
-  const devApps = await getAllApps({ dev: true })
+  const devApps = await dbCore.getAllApps({ dev: true })
   const appCount = devApps ? devApps.length : 0
 
   // sync app count
-  const tenantId = getTenantId()
+  const tenantId = tenancy.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,12 +1,11 @@
-import { getTenantId } from "@budibase/backend-core/tenancy"
-import { getAllApps } from "@budibase/backend-core/db"
+import { tenancy, db as dbCore } from "@budibase/backend-core"
 import { getUniqueRows } from "../../../utilities/usageQuota/rows"
 import { quotas } from "@budibase/pro"
-import { StaticQuotaName, QuotaUsageType } from "@budibase/types"
+import { StaticQuotaName, QuotaUsageType, App } from "@budibase/types"
 
 export const run = async () => {
   // get all rows in all apps
-  const allApps = await getAllApps({ all: true })
+  const allApps = (await dbCore.getAllApps({ all: true })) as App[]
   const appIds = allApps ? allApps.map((app: { appId: any }) => app.appId) : []
   const { appRows } = await getUniqueRows(appIds)
 
@@ -19,7 +18,7 @@ export const run = async () => {
   })
 
   // sync row count
-  const tenantId = getTenantId()
+  const tenantId = tenancy.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 { getProdAppID } = require("@budibase/backend-core/db")
+const { db: dbCore } = require("@budibase/backend-core")
 
 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?.[getProdAppID(app1.appId)].usageQuota.rows).toEqual(
-        1
-      )
-      expect(usageDoc.apps?.[getProdAppID(app2.appId)].usageQuota.rows).toEqual(
-        2
-      )
+      expect(
+        usageDoc.apps?.[dbCore.getProdAppID(app1.appId)].usageQuota.rows
+      ).toEqual(1)
+      expect(
+        usageDoc.apps?.[dbCore.getProdAppID(app2.appId)].usageQuota.rows
+      ).toEqual(2)
     })
   })
 })

package/src/migrations/functions/userEmailViewCasing.ts

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

package/src/migrations/tests/index.spec.ts

@@ -6,7 +6,7 @@ import {
   context,
 } from "@budibase/backend-core"
 import TestConfig from "../../tests/utilities/TestConfiguration"
-import structures from "../../tests/utilities/structures"
+import * as structures from "../../tests/utilities/structures"
 import { MIGRATIONS } from "../"
 import * as helpers from "./helpers"
 

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

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