@budibase/server 2.1.31 → 2.1.32-alpha.0

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

@@ -2,11 +2,11 @@ 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 } 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 getAllApps({ all: true })) as App[]
   const appIds = allApps ? allApps.map((app: { appId: any }) => app.appId) : []
   const { appRows } = await getUniqueRows(appIds)
 

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

@@ -1,4 +1,5 @@
 import { db as dbCore } from "@budibase/backend-core"
+import { Database } from "@budibase/types"
 import { getAutomationParams, TABLE_ROW_PREFIX } from "../../../db/utils"
 import { budibaseTempDir } from "../../../utilities/budibaseDir"
 import { DB_EXPORT_FILE, GLOBAL_DB_EXPORT_FILE } from "./constants"
@@ -17,7 +18,6 @@ import {
   CouchFindOptions,
   RowAttachment,
 } from "@budibase/types"
-import PouchDB from "pouchdb"
 const uuid = require("uuid/v4")
 const tar = require("tar")
 
@@ -29,10 +29,7 @@ type TemplateType = {
   key?: string
 }
 
-async function updateAttachmentColumns(
-  prodAppId: string,
-  db: PouchDB.Database
-) {
+async function updateAttachmentColumns(prodAppId: string, db: Database) {
   // iterate through attachment documents and update them
   const tables = await sdk.tables.getAllInternalTables(db)
   for (let table of tables) {
@@ -86,7 +83,7 @@ async function updateAttachmentColumns(
   }
 }
 
-async function updateAutomations(prodAppId: string, db: PouchDB.Database) {
+async function updateAutomations(prodAppId: string, db: Database) {
   const automations = (
     await db.allDocs(
       getAutomationParams(null, {
@@ -154,7 +151,7 @@ export function getListOfAppsInMulti(tmpPath: string) {
 
 export async function importApp(
   appId: string,
-  db: PouchDB.Database,
+  db: Database,
   template: TemplateType
 ) {
   let prodAppId = dbCore.getProdAppID(appId)

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

@@ -1,13 +1,13 @@
 import { context, db as dbCore } from "@budibase/backend-core"
+import { Database } from "@budibase/types"
 import {
   getDatasourceParams,
   getTableParams,
   getAutomationParams,
   getScreenParams,
 } from "../../../db/utils"
-import PouchDB from "pouchdb"
 
-async function runInContext(appId: string, cb: any, db?: PouchDB.Database) {
+async function runInContext(appId: string, cb: any, db?: Database) {
   if (db) {
     return cb(db)
   } else {
@@ -19,13 +19,10 @@ async function runInContext(appId: string, cb: any, db?: PouchDB.Database) {
   }
 }
 
-export async function calculateDatasourceCount(
-  appId: string,
-  db?: PouchDB.Database
-) {
+export async function calculateDatasourceCount(appId: string, db?: Database) {
   return runInContext(
     appId,
-    async (db: PouchDB.Database) => {
+    async (db: Database) => {
       const datasourceList = await db.allDocs(getDatasourceParams())
       const tableList = await db.allDocs(getTableParams())
       return datasourceList.rows.length + tableList.rows.length
@@ -34,13 +31,10 @@ export async function calculateDatasourceCount(
   )
 }
 
-export async function calculateAutomationCount(
-  appId: string,
-  db?: PouchDB.Database
-) {
+export async function calculateAutomationCount(appId: string, db?: Database) {
   return runInContext(
     appId,
-    async (db: PouchDB.Database) => {
+    async (db: Database) => {
       const automationList = await db.allDocs(getAutomationParams())
       return automationList.rows.length
     },
@@ -48,13 +42,10 @@ export async function calculateAutomationCount(
   )
 }
 
-export async function calculateScreenCount(
-  appId: string,
-  db?: PouchDB.Database
-) {
+export async function calculateScreenCount(appId: string, db?: Database) {
   return runInContext(
     appId,
-    async (db: PouchDB.Database) => {
+    async (db: Database) => {
       const screenList = await db.allDocs(getScreenParams())
       return screenList.rows.length
     },
@@ -63,7 +54,7 @@ export async function calculateScreenCount(
 }
 
 export async function calculateBackupStats(appId: string) {
-  return runInContext(appId, async (db: PouchDB.Database) => {
+  return runInContext(appId, async (db: Database) => {
     const promises = []
     promises.push(calculateDatasourceCount(appId, db))
     promises.push(calculateAutomationCount(appId, db))

package/src/sdk/app/tables/index.ts

@@ -1,16 +1,15 @@
-import { getAppDB } from "@budibase/backend-core/context"
+import { context } from "@budibase/backend-core"
 import { BudibaseInternalDB, getTableParams } from "../../../db/utils"
 import {
   breakExternalTableId,
   isExternalTable,
   isSQL,
 } from "../../../integrations/utils"
-import { Table } from "@budibase/types"
-import PouchDB from "pouchdb"
+import { Table, Database } from "@budibase/types"
 
-async function getAllInternalTables(db?: PouchDB.Database): Promise<Table[]> {
+async function getAllInternalTables(db?: Database): Promise<Table[]> {
   if (!db) {
-    db = getAppDB() as PouchDB.Database
+    db = context.getAppDB()
   }
   const internalTables = await db.allDocs(
     getTableParams(null, {
@@ -25,7 +24,7 @@ async function getAllInternalTables(db?: PouchDB.Database): Promise<Table[]> {
 }
 
 async function getAllExternalTables(datasourceId: any): Promise<Table[]> {
-  const db = getAppDB()
+  const db = context.getAppDB()
   const datasource = await db.get(datasourceId)
   if (!datasource || !datasource.entities) {
     throw "Datasource is not configured fully."
@@ -42,7 +41,7 @@ async function getExternalTable(
 }
 
 async function getTable(tableId: any): Promise<Table> {
-  const db = getAppDB()
+  const db = context.getAppDB()
   if (isExternalTable(tableId)) {
     let { datasourceId, tableName } = breakExternalTableId(tableId)
     const datasource = await db.get(datasourceId)

package/{scripts/jestSetup.js → src/tests/jestSetup.ts}

@@ -1,5 +1,5 @@
 const { tmpdir } = require("os")
-const env = require("../src/environment")
+import env from "../environment"
 
 env._set("SELF_HOSTED", "1")
 env._set("NODE_ENV", "jest")
@@ -8,8 +8,11 @@ env._set("CLIENT_ID", "test-client-id")
 env._set("BUDIBASE_DIR", tmpdir("budibase-unittests"))
 env._set("LOG_LEVEL", "silent")
 env._set("PORT", 0)
+env._set("MINIO_URL", "http://localhost")
+env._set("MINIO_ACCESS_KEY", "test")
+env._set("MINIO_SECRET_KEY", "test")
 
-const { mocks } = require("@budibase/backend-core/tests")
+import { mocks } from "@budibase/backend-core/tests"
 
 // mock all dates to 2020-01-01T00:00:00.000Z
 // use tk.reset() to use real dates in individual tests
@@ -17,3 +20,9 @@ const tk = require("timekeeper")
 tk.freeze(mocks.date.MOCK_DATE)
 
 global.console.log = jest.fn() // console.log are ignored in tests
+
+if (!process.env.CI) {
+  // set a longer timeout in dev for debugging
+  // 100 seconds
+  jest.setTimeout(100000)
+}

package/src/tests/utilities/TestConfiguration.js

@@ -16,7 +16,7 @@ const {
 const controllers = require("./controllers")
 const supertest = require("supertest")
 const { cleanup } = require("../../utilities/fileSystem")
-const { Cookies, Headers } = require("@budibase/backend-core/constants")
+const { Cookie, Header } = require("@budibase/backend-core/constants")
 const { jwt } = require("@budibase/backend-core/auth")
 const { doInTenant, doWithGlobalDB } = require("@budibase/backend-core/tenancy")
 const { createASession } = require("@budibase/backend-core/sessions")
@@ -116,7 +116,9 @@ class TestConfiguration {
     if (this.server) {
       this.server.close()
     }
-    cleanup(this.allApps.map(app => app.appId))
+    if (this.allApps) {
+      cleanup(this.allApps.map(app => app.appId))
+    }
   }
 
   // UTILS
@@ -254,10 +256,10 @@ class TestConfiguration {
       return {
         Accept: "application/json",
         Cookie: [
-          `${Cookies.Auth}=${authToken}`,
-          `${Cookies.CurrentApp}=${appToken}`,
+          `${Cookie.Auth}=${authToken}`,
+          `${Cookie.CurrentApp}=${appToken}`,
         ],
-        [Headers.APP_ID]: appId,
+        [Header.APP_ID]: appId,
       }
     })
   }
@@ -277,14 +279,14 @@ class TestConfiguration {
     const headers = {
       Accept: "application/json",
       Cookie: [
-        `${Cookies.Auth}=${authToken}`,
-        `${Cookies.CurrentApp}=${appToken}`,
+        `${Cookie.Auth}=${authToken}`,
+        `${Cookie.CurrentApp}=${appToken}`,
       ],
-      [Headers.CSRF_TOKEN]: CSRF_TOKEN,
+      [Header.CSRF_TOKEN]: CSRF_TOKEN,
       ...extras,
     }
     if (this.appId) {
-      headers[Headers.APP_ID] = this.appId
+      headers[Header.APP_ID] = this.appId
     }
     return headers
   }
@@ -296,7 +298,7 @@ class TestConfiguration {
       Accept: "application/json",
     }
     if (appId) {
-      headers[Headers.APP_ID] = appId
+      headers[Header.APP_ID] = appId
     }
     return headers
   }

package/src/tests/utilities/structures.js

@@ -1,5 +1,5 @@
 const { BUILTIN_ROLE_IDS } = require("@budibase/backend-core/roles")
-const { BUILTIN_PERMISSION_IDS } = require("@budibase/backend-core/permissions")
+const { BuiltinPermissionID } = require("@budibase/backend-core/permissions")
 const { createHomeScreen } = require("../../constants/screens")
 const { EMPTY_LAYOUT } = require("../../constants/layouts")
 const { cloneDeep } = require("lodash/fp")
@@ -135,7 +135,7 @@ exports.basicRole = () => {
   return {
     name: "NewRole",
     inherits: BUILTIN_ROLE_IDS.BASIC,
-    permissionId: BUILTIN_PERMISSION_IDS.READ_ONLY,
+    permissionId: BuiltinPermissionID.READ_ONLY,
   }
 }